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

Beef y C3, dos lenguajes de programación que evolucionan a C

En este 2026 la programación será cada vez más díficil de aprender y enseñar. La I.A. ha surgido como una herramienta útil para el desarrollador moderno, aunque también un lastre para quienes no quieren evolucionar (o morir en el intento). Es por eso que es necesario el estudio y práctica de la programación.

Existen dos lenguajes llamados Beef y C3 respectivamente que prometen ser la evolución directa al lenguaje mítico C.

Beef se siente como un híbrido entre C++ y C#, con tooling propio y características modernas (tuplas, pattern matching, mixins, reflexión, compilación en caliente). Es ideal para quienes buscan un lenguaje nativo con ecosistema completo y mayor productividad.

La documentación oficial nos dice:

"Beef es un lenguaje de programación de código abierto multiparadigma de alto rendimiento centrado en la productividad del desarrollador".

Beef soporta programación orientada a objetos, funcional y estructurada.

Enfocado a la alta productividad y rendimiento, con fuerte integración C/C++. Busca ser un lenguaje moderno para aplicaciones nativas con tooling propio (IDE, depurador, profiler).

C3 es más conservador. Se mantiene muy cerca de C, pero añade mejoras puntuales (contratos, macros más potentes, genéricos claros, mejor manejo de errores). Es atractivo para proyectos que ya usan C y quieren evolucionar sin perder compatibilidad.

La documentación oficial nos dice:

"C3 es una evolución, no una revolución: el C-like para programadores a quienes les gusta C".

El paradigma de C3 es ser imperativo y estructurado, con extensiones modernas (contratos, macros, genéricos).

Se conidera así mismo como una evolución ergonómica de C, manteniendo compatibilidad total con ABI de C. Su meta es mejorar la seguridad y expresividad sin perder la familiaridad para programadores de C.

Cada uno tiene sus propias características y peculiaridades.

Filosofía de Beef

Se basa en:

• "Productividad sin sacrificar rendimiento". 
• Ofrece compilación incremental, detección de fugas en tiempo real, generación de código en tiempo de compilación y un IDE dedicado.
• Se centra en mejorar la experiencia del desarrollador.

Filosofía de C3

Se basa en:

• "Una evolución, no una revolución". 
• Mantiene la simplicidad y cercanía a C, pero añade contratos, macros semánticos, reflexión y manejo de errores más seguro. 
•  Busca ser C mejorado, no reemplazarlo.

Relación con C/C++

Beef:

• Interoperabilidad directa con librerías C/C++ (estáticas y dinámicas).
• Permite mezclar niveles de optimización en un mismo proyecto.
• Sintaxis inspirada en C#, pero con bajo nivel similar a C++.

C3:

• Compatibilidad ABI completa con C.
• Puede integrarse en proyectos C/C++ sin esfuerzo.
• Sintaxis muy cercana a C, con mejoras inspiradas en C++ pero sin su complejidad.

Instalación

Ambos lenguajes pueden ser instalados en plataformas Linux, Mac OS y Windows.

Este es el IDE de Beef

Hola mundo

Observemos el clásico programa de "Hola, mundo" escrito en ambos lenguajes.

Beef:

HolaMundo.bf

using System;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Hola, mundo en Beef!");
    }
}

Como se puede observar, la extensión de un programa Beef es *.bf.

Beef puede usarse desde una terminal o desde su IDE.

Podemos crear un proyecto con los siguientes comandos:

$ beef new HolaMundo

Coloca el código en HolaMundo/src/HolaMundo.bf

Ejecuta el proyecto:

$ beef run

C3:

holamundo.c3

module hola_mundo;
import std::io;

fn void main()
{
io::printn("Hola, mundo en C3!");
}

La extensión de un programa en C3 no podría ser otro que *.c3.

Tiene una cercanía más expresiva a C.

Compilamos:

$ c3c compile holamundo.c3 -o holamundo

Ejecutamos:

$ holamundo.exe

Tipos de datos y estructuras de control básicas

Ejemplo 1. Crear un programa que muestre los tipos de datos y estructuras de control en ambos lenguajes. Para el caso de Beef usaremos su IDE. C3 será compilado y ejecutado desde terminal

Beef:

Program.bf

using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
		TestA();
		TestB();
    }

	static void TestA(){
		Console.WriteLine("\t [ Tipos de variables en Beef ]");
		int entero = 42;
		float flotante = 3.14f;
		double doble = 2.71828;
		bool booleano = true;
		char8 caracter = 'A';
		String texto = "Hola, mundo";

		Console.WriteLine($"Entero: {entero}");
		Console.WriteLine($"Flotante: {flotante}");
		Console.WriteLine($"Doble: {doble}");
		Console.WriteLine($"Booleano: {booleano}");
		Console.WriteLine($"Caracter: {caracter}");
		Console.WriteLine($"Texto: {texto}");

	}


	static void TestB(){
		Console.WriteLine("\t [ Estructuras de control en Beef ]");
		bool numeroV =  23 > 20;
		if(numeroV){
			Console.WriteLine("Verdadero: 23 > 20");
			numeroV = 300 < 100;
		}

		if(numeroV){
			Console.WriteLine("Verdadero: 300 < 10");
		}else{
			Console.WriteLine("Falso: 300 < 100");
		}

		int x = 3;
		if (x < 0)
		    Console.WriteLine("x es negativo");
		else if (x == 0)
		    Console.WriteLine("x es cero");
		else
		    Console.WriteLine("x es positivo");

		switch (x)
		{
		    case 1:
		        Console.WriteLine("x es uno");
		        break;
		    case 10:
		        Console.WriteLine("x es diez");
		        break;
		    default:
			    Console.WriteLine($"x no es ni 1 ni 10 es: {x}");    
		        break;
		}


	}


}

Salida:

         [ Fundamentos de Beef ]
         [ Tipos de variables en Beef ]
Entero: 42
Flotante: 3.14
Doble: 2.71828
Booleano: True
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en Beef ]
Verdadero: 23 > 20
Falso: 300 < 100
x es positivo
x no es ni 1 ni 10 es: 3

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
    test_b();
}

fn void test_b()
{
   io::printn("\t [ Estructuras de control en C3 ]");
    int x = 10;

   
    if (x > 5){
        io::printn("x es mayor que 5");
    }
    
    if (x % 2 == 0){
        io::printn("x es par");
    }else{
        io::printn("x es impar");
    }
   
    if (x < 0){
        io::printn("x es negativo");
    }else if (x == 0){
        io::printn("x es cero");
    }else{
        io::printn("x es positivo");
    }
    
    switch (x) {
        case 1:
            io::printn("x es uno");
            break;
        case 10:
            io::printn("x es diez");
            break;
        default:
            io::printf("x no es ni 1 ni 10 es: %d\n", x);
            break;
    }
}

fn void test_a()
{
    io::printn("\t [ Tipos de datos en C3 ]");

    int entero = 42;
    float flotante = 3.14f;
    double doble = 2.71828;
    bool booleano = true;
    char caracter = 'A';
    ZString texto = (ZString)"Hola, mundo";


    io::printf("Entero: %d\n", entero);
    io::printf("Flotante: %f\n", flotante);
    io::printf("Doble: %f\n", doble);
    io::printf("Booleano: %s\n", booleano ? "true" : "false");
    io::printf("Caracter: %c\n", caracter);
    io::printf("Texto: %s\n", texto);
}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Tipos de datos en C3 ]
Entero: 42
Flotante: 3.140000
Doble: 2.718280
Booleano: true
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en C3 ]
x es mayor que 5
x es par
x es positivo
x es diez

Ejemplo 2. Crear un programa que muestre las estructuras de control iterativas como for, while y foreach.

Beef:

Program.bf

         using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
        TestA();
    }


    static void TestA()
    {
        Console.WriteLine("\t [ Estructuras de control iterativas en Beef ]");

	    // for
	    for (int x = 0; x < 5; x++){
			Console.WriteLine($"for: i = {x}");
		}
	        

	    // while
	    int j = 0;
	    while (j < 5)
	    {
	        Console.WriteLine($"while: j = {j}");
	        j++;
	    }

	    // do-while
	    int k = 0;
	    do repeat
	    {
	        Console.WriteLine($"do-while: k = {k}");
	        k++;
	    } while (k < 5);

	    
		int[] numeros = new int[] { 1, 2, 3, 4, 5 };
		// foreach para recorrerlo
		foreach (int n in numeros){
			Console.WriteLine($"foreach: n = {n}");
		}
		 
    }
}

Salida:

         [ Fundamentos de Beef ]
         [ Estructuras de control iterativas en Beef ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
foreach: n = 1
foreach: n = 2
foreach: n = 3
foreach: n = 4
foreach: n = 5

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
}

fn void test_a()
{
   io::printn("\t [ Estructuras de control iterativas en C3 ]");
    
    for (int i = 0; i < 5; i++){
        io::printf("for: i = %d\n", i);
    }
    
    int j = 0;
    while (j < 5) {
        io::printf("while: j = %d\n", j);
        j++;
    }

    
    int k = 0;
    do {
        io::printf("do-while: k = %d\n", k);
        k++;
    } while (k < 5);

    

   int[5] numeros = {1, 2, 3, 4, 5};
    for (int idx = 0; idx < numeros.len; idx++){
        io::printf("array[%d] = %d\n", idx, numeros[idx]);
   }

}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Estructuras de control iterativas en C3 ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

En conclusión:

• Si buscas un lenguaje moderno con tooling completo y sintaxis más expresiva, Beef es la apuesta. 
•  Si prefieres una transición suave desde C, con mejoras de seguridad y ergonomía pero sin perder compatibilidad total, C3 es la opción.

Continuaremos con esta serie sobre lenguajes de programación.

Enlaces:

https://www.beeflang.org/
https://c3-lang.org/

OpenCode: un agente para escribir código

OpenCode es una alternativa Open Source a herramientas como Claude Code.

Está disponible como interfaz de terminal, aplicación de escritorio o extensión de IDE. Sirve para acelerar el desarrollo de software al generar, analizar, editar y corregir código. Permite multisesiones, se conecta con Github Copilot, entre otras cosas más.

Puedes usarlo a la par con ChatGPT Plus/Pro, Github Copilot, etc. mediante una subscripción. Aunque no necesitas necesariamente una subscripción para usar OpenCode. Además te permite personalizarlo.

En pocas palabras, con OpenCode podrás crear código de manera fácil desde una terminal.

¿Cómo instalo OpenCode?

Requisitos:

• Emulador de terminal moderno: WezTerm, Alacritty, Ghostty o Kitty. 
• Claves API: Debes tener credenciales de los proveedores de LLM que quieras usar (ej. OpenAI, Anthropic, Google Gemini). 
• Sistema operativo compatible: macOS, Linux o Windows (con WSL recomendado).

Existen varias formas de hacerlo.

En entornos Linux:

$ curl -fsSL https://opencode.ai/install | bash

Con Node JS:

# npm
$ npm install -g opencode-ai

# bun
$ bun install -g opencode-ai

# pnpm
$ pnpm install -g opencode-ai

# yarn
$ yarn global add opencode-ai

En entornos Mac OS:

$ brew install anomalyco/tap/opencode

Con un instalador .exe (Windows):

https://opencode.ai/download

Verificamos la instalación:

$ opencode --version

OpenCode necesita conectarse a modelos de IA. Puedes configurar tus credenciales en el archivo de configuración:

$ opencode config set 
$ openai_api_key=TU_API_KEY
$ opencode config set anthropic_api_key=TU_API_KEY
$ opencode config set gemini_api_key=TU_API_KEY

Seleccionamos un modelo por defecto:

$ opencode config set default_model=openai:gpt-4

Podemos abrirlo de manera interactiva:

$ opencode 

También escribiendo un prompt de manera directa:

$ opencode "Escribe un script en Python que calcule la serie de Fibonacci"

Conclusiones:

OpenCode (y herramientas similares) ayudará a los programadores a hacer su trabajo más rápido y a otros les hará creer que son programadores sin serlo (como lo hizo Visual Basic en su momento).

La I.A. ya llegó. Lo que imaginabamos o veíamos en series o películas de ciencia ficción se ha vuelto una realidad. El programador pronto pasará a ser un espectador (lo queramos o no) que solicita X o Y cosa para que un asistente virtual nos sirva lo solicitado.

El futuro es la automatización del trabajo. No ayudar al trabajador a hacer su trabajo más rápido. No, no es el caso.

2026 mostrará la otra cara de la I.A. una que casi nadie quiere ver: el desplazamiento del humano por un agente virtual.

Quien se duerma en sus laureles pronto será reemplazado. Ese es el plan a futuro. Solo un tonto no lo verá de ese modo.

Enlaces:

https://opencode.ai/
https://lapascalinaatomica.blogspot.com/2026/02/fortran-oberon-y-pascal-frente-la-ia.html