Tutorial de V++, de cero a avanzado

Qué es V++ y por qué

V++ es un lenguaje de programación cuyas palabras clave son palabras en español: sea, funcion, si, sino, mientras, para, regresa. No traduces tu pensamiento a otro idioma para programar: escribes directamente en el tuyo.

Su rasgo más profundo es la independencia. V++ está autohospedado: su propio compilador está escrito en V++ (vppc_self.vpp) y produce binarios nativos ARM64 sin depender de compiladores ajenos. El sitio que estás leyendo se sirve con un servidor escrito en V++. El lenguaje no le pide permiso a nadie para existir.

La aritmética es entera y determinista por diseño, los diagnósticos están en español con línea, columna y carete, y toda la plataforma —intérprete portable, compilador nativo, biblioteca estándar y herramientas— es de una sola pieza.

Instalación

Descarga la plataforma desde /descargas. Incluye el intérprete portable (ejecuta al instante, ideal para aprender) y el compilador nativo (produce binarios ARM64 autónomos). Una vez descomprimido, todo se maneja con el comando vpp:

# ejecutar un programa con el intérprete portable
./vpp corre programa.vpp

# terminal interactiva (REPL)
./vpp repl

# formatear y revisar código
./vpp fmt programa.vpp
./vpp lint programa.vpp

# compilar a un binario nativo ARM64
./vpp nativo programa.vpp

Si no quieres instalar nada todavía, el Playground y el tutorial interactivo corren V++ en tu navegador.

Tu primer programa: Hola, mundo

La instrucción escribe imprime una línea de texto. Guarda esto en hola.vpp y ejecútalo con vpp corre hola.vpp.

escribe "Hola, mundo"

Hola, mundo

Para imprimir el resultado numérico de una expresión se usa escribe_num. V++ distingue entre imprimir texto (escribe) e imprimir números (escribe_num).

escribe "Hola, mundo"
escribe_num 6 * 7

Hola, mundo
42

Variables y tipos

Con sea declaras una variable; reasignas con nombre = …. Con constante declaras un valor que no se puede reasignar (intentarlo detiene el programa con un error claro). Los tipos básicos son enteros, reales, cadenas de texto y valores booleanos (verdad = 1, falso = 0).

sea nombre = "México"
constante PAIS = "MX"
escribe "Hola, " + nombre
escribe "tienes {2 + 3} amoxes"

Hola, México
tienes 5 amoxes

El operador + une textos y también pega un número a un texto. En la última línea aparece la interpolación de cadenas: dentro de un literal, {expr} se sustituye por el resultado de evaluar la expresión. Para escribir llaves literales usa {{ y }}; si el contenido entre llaves no es una expresión V++ válida (por ejemplo CSS o JSON), la cadena queda tal cual.

Control de flujo

La decisión se escribe con si, el bloque alternativo con sino, y todo cierra con fin. Los comparadores son == != < > <= >= y los operadores lógicos son palabras: y, o, no.

sea edad = 21
si edad >= 18:
  escribe "mayor de edad"
sino:
  escribe "menor de edad"
fin
si edad > 12 y edad < 18:
  escribe "adolescente"
fin

mayor de edad

Para repetir hay dos ciclos. mientras repite su bloque mientras la condición sea verdadera; recuerda avanzar la variable de control. para i en rango(a, b) recorre de a hasta b - 1.

sea i = 1
mientras i <= 3:
  escribe_num i
  i = i + 1
fin

para j en rango(0, 3):
  escribe_num j * 10
fin

1
2
3
0
10
20

Funciones y recursión

Con funcion nombre(parámetros): … fin defines lógica reutilizable y regresa devuelve el resultado. Las funciones pueden llamarse a sí mismas (recursión).

funcion factorial(n):
  si n <= 1:
    regresa 1
  fin
  regresa n * factorial(n - 1)
fin

escribe_num factorial(6)

720

Una función puede devolver varios valores a la vez, y los desestructuras al recibirlos:

funcion divmod2(a, b):
  regresa a / b, a % b
fin

sea c, r = divmod2(17, 5)
escribe_num c
escribe_num r

3
2

La división entre enteros trunca: 17 / 5 da 3 y 17 % 5 da el residuo 2.

Listas, mapas y cadenas

Una lista se crea con lista(). lista_agregar añade al final, lista_obtener lee por índice (empieza en 0) y longitud mide. Un mapa se crea con mapa() y se maneja con mapa_poner, mapa_obtener y mapa_tiene.

sea L = lista()
sea a = lista_agregar(L, 4)
sea b = lista_agregar(L, 8)
sea c = lista_agregar(L, 15)
escribe_num longitud(L)
escribe_num lista_obtener(L, 0)

sea M = mapa()
sea p = mapa_poner(M, "x", 7)
escribe_num mapa_obtener(M, "x")

3
4
7

Las cadenas también se miden con longitud y se leen letra a letra con caracter(cadena, i). Junto con la interpolación del capítulo 4, tienes todo para construir texto:

sea palabra = "mexicano"
escribe_num longitud(palabra)
escribe caracter(palabra, 0)
escribe palabra + " digital"

8
s
mexicano digital

La biblioteca Amoxkalli

Amoxkalli (del náhuatl āmox, códice) es la biblioteca estándar de V++: 783 módulos —llamados amoxes— con 13 926 pruebas ejecutables, todas verdes, en aritmética entera pura. Un amox se trae con importa y sus funciones quedan disponibles. Por ejemplo, el amox romano convierte a números romanos y de vuelta:

importa "romano.vpp"

escribe a_romano(2024)
escribe_num de_romano("MMXXIV")

MMXXIV
2024

El catálogo cubre estructuras de datos (árboles, trie, unión-find, grafos con Dijkstra), codificación (Base64/32/58, hex, CRC), matemática modular y de precisión arbitraria, dominio mexicano (CURP, RFC, CLABE), texto y PLN en español, geometría 2D/3D, estadística, finanzas, fecha y tiempo, criptografía clásica, y decenas de dominios de ingeniería y ciencia. La lista completa está en /descargas.

Concurrencia CSP

V++ trae concurrencia estilo CSP (procesos que se comunican por canales), cooperativa y 100 % determinista: no hay condiciones de carrera por diseño, porque solo un proceso avanza a la vez.

Un productor deposita cinco cuadrados en un canal y el programa principal los suma:

funcion productor(c, n):
  para i en rango(1, n + 1):
    envia(c, i * i)
  fin
fin

sea c1 = canal()
lanza productor(c1, 5)
sea suma = 0
para i en rango(0, 5):
  suma = suma + recibe(c1)
fin
escribe_num suma

55

Regiones de memoria

El compilador nativo de V++ usa una arena de 1 GB con asignación por bump pointer: rápida, sin fragmentación y sin malloc. Para liberar memoria temporal en bloques, existe el par marcar_arena() / liberar_arena(m), un patrón de región por ámbito:

sea m = marcar_arena()      // guarda la marca (bytes usados hoy)
sea t = a + a               // asignaciones temporales en la arena
sea lt = longitud(t)
liberar_arena(m)            // libera TODO lo asignado tras la marca

liberar_arena(m) es O(1) y libera de golpe todo lo asignado después de la marca. La regla de oro: no uses ninguna referencia creada tras la marca una vez liberada (copia antes lo que necesites conservar, como un entero). Los pares pueden anidarse en orden LIFO. Con este patrón, un bucle que crearía 115 MB de cadenas temporales corre en arena constante.

Pruebas

V++ trae su propio corredor de pruebas. Escribe afirmaciones con afirma(condicion, "mensaje"): si la condición es falsa, la prueba falla con ese mensaje. Se corren con vpp prueba.

// Prueba V++: aritmetica basica · CEOO Tecnologías
afirma(2 + 3 == 5, "suma")
afirma(10 - 4 == 6, "resta")
afirma(6 * 7 == 42, "multiplicacion")
afirma(17 / 5 == 3, "division entera")
afirma(7 % 3 == 1, "modulo")
escribe("aritmetica: ok")

./vpp prueba prueba_aritmetica.vpp

PASA  prueba_aritmetica.vpp
PRUEBAS: 1 pasan, 0 fallan

Paquetes

Un proyecto V++ se crea con vpp nuevo, que genera el manifiesto vpp.toml, un principal.vpp, una prueba y un LEEME.md. El manifiesto declara nombre, versión y dependencias:

[proyecto]
nombre = "demo"
version = "0.1.0"
descripcion = "Proyecto V++ propio"

[dependencias]
geometria = "0.1.0"

# crear un proyecto nuevo
vpp nuevo demo && cd demo

# instalar dependencias del registro propio y fijar vpp.lock
vpp instala

# instalar un módulo suelto
vpp instala geometria

vpp instala lee el manifiesto, descarga las dependencias del registro propio y escribe un lockfile vpp.lock con el sha256 de cada paquete. Si un solo byte cambia, la instalación aborta: reproducibilidad verificable. El parser de TOML es propio y mínimo, a propósito: menos superficie, cero ambigüedad.

Compilación nativa a ARM64

Más allá del intérprete, V++ compila a binarios nativos ARM64 (Mach-O) mediante vppc, su compilador escrito en el propio V++. El binario resultante no depende de ningún runtime externo.

# compilar programa.vpp a un ejecutable nativo
./vpp nativo programa.vpp

# ejecutar el binario resultante (sin intérprete)
./programa

El modelo de ejecución nativo: enteros de 64 bits, flotantes IEEE, cadenas inmutables en la arena, un marco de pila por función con soporte de recursión, y las regiones de memoria del capítulo 10. El compilador ofrece además un optimizador -O. Este es el corazón de la independencia de V++: el lenguaje se compila a sí mismo hasta el metal, sin intermediarios.

CEOONIK · K'iin · MUT

V++ carga una identidad cultural propia en tres capas.

CEOONIK — el cifrado propio

CEOONIK es un códec biyectivo donde cada mensaje se inscribe como un recorrido de puntos sobre un dodecaedro regular. La proyección 2D de ese recorrido es un glifo: sin la llave, el glifo es ruido geométrico; con la llave, es lenguaje. Conócelo en /ceoonik.

K'iin — la capa maya

K'iin ofrece alias en lengua maya sobre el vocabulario del lenguaje, para escribir V++ desde otra raíz cultural viva de México. Su lema: «Hoy mi enseñanza camina.» Está en /kiin.

MUT — la terminal propia

MUT es la identidad de la terminal de V++: el look y la experiencia de línea de comandos con la que corres vpp corre, vpp repl y todo lo demás. Toda la herramienta habla el mismo idioma que tu código.

Siguientes pasos

Ya conoces V++ de principio a fin. Para seguir:

• Tutorial interactivo — 10 lecciones que corren en tu navegador y verifican tu salida.
• Playground — escribe y ejecuta cualquier programa V++ al instante.
• Casos reales — V++ resolviendo problemas de verdad.
• V++ frente al mundo — cómo se compara con otros lenguajes.
• Especificación — la referencia formal del lenguaje.
• Roadmap — hacia dónde va la plataforma.
• Descargas — la plataforma completa: intérprete, compilador nativo y Amoxkalli.

Todo pueblo que no programa en su propia lengua, obedece la lógica de otro.