Nuevo Juegos 2D con Pincel ✨

Programa en tu idioma.

Cometa es un lenguaje de programación tipado con sintaxis en español. Sirve para aprender a programar desde cero y también para hacer juegos y herramientas. Tus programas se compilan a Go.

Empezar ahora Ver ejemplos

Tipado estático
Sin nulos
Compila a Go

hola.cometa

tipo Explorador
	nombre cadena
	nivel entero

	pub fn saludar() cadena
		"¡Hola, ${@nombre}! Estás en el nivel ${@nivel}."

fn inicio()
	var ana = Explorador {nombre: "Ana", nivel: 3}
	imprimir(ana.saludar())

	repetir (3..0, paso = -1) |i|
		imprimir("Despegue en ${i}...")
	imprimir("¡Vuela, cometa!")

▶ cometa ejecutar hola.cometa¡Hola, Ana! Estás en el nivel 3.Despegue en 3...Despegue en 2...Despegue en 1...¡Vuela, cometa!

// por qué cometa

Fácil para empezar.
Potente para crecer.

Cometa es sencillo de escribir, y lo que aprendes con él te sirve en otros lenguajes.

ñ
Sintaxis en español
Las palabras clave son si, sino, repetir y casos. Puedes leer el código en voz alta y se entiende.
si nota >= 90 "¡Excelente!" sino "¡Bien!"
T
Tipos
El tipado es estático. Cometa deduce el tipo de cada variable a partir de su valor y encuentra los errores antes de ejecutar el programa.
var puntos = 10 // entero
T?
Sin nulos
Un valor que puede faltar es un opcional T? y una operación que puede fallar devuelve un resultado T!. El compilador te pide decidir qué hacer en cada caso antes de usar el valor.
var nombre = usuario.apodo o "Anónimo"
Go
Programas rápidos
Cometa compila a Go, así que obtienes un ejecutable nativo y rápido que puedes compartir.
cometa construir juego.cometa -o juego.exe
▶
Juegos 2D incluidos
Pincel trae gráficos, entrada, audio y un modo retro con fuentes e íconos pixelados.
retro.icono(.Corazon, 8, 24, color = .Rojo)
{ }
El editor te ayuda
La extensión de VS Code trae un servidor de lenguaje que muestra los errores mientras escribes, autocompleta y te lleva a la definición de cada nombre.
imprimir(a_cadena(.V4)) // ← sugerencias

// ejemplos

Así se escribe en Cometa.

Ejemplos desde un primer programa hasta los tipos genéricos.

basico.cometa

// Las funciones devuelven su última expresión.
fn area(ancho decimal, alto decimal) decimal ancho * alto

fn saludar(nombre cadena = "mundo") cadena
	"¡Hola, ${nombre}!"

fn inicio()
	var frutas = ["mango", "papaya", "guayaba"]

	repetir (frutas) |fruta|
		imprimir("Me gusta la ${fruta.mayusculas()}")

	var nota = 87
	var mensaje = si nota >= 90 "¡Excelente!" sino "¡Muy bien!"
	imprimir(mensaje)
	imprimir(saludar())
	imprimir(area(3, 4.5))

Bloques con tabulaciones, interpolación con ${ } y funciones que devuelven su última expresión.

formas.cometa

enum Forma
	Circulo decimal
	Cuadrado decimal
	Punto

fn area(forma Forma) decimal
	// casos es exhaustivo: el compilador revisa cada variante.
	casos forma |medida|
		.Circulo => 3.1416 * medida * medida
		.Cuadrado => medida * medida
		.Punto => 0

fn inicio()
	var formas [Forma] = [.Circulo(2), .Cuadrado(3), .Punto]
	repetir (formas) |forma|
		imprimir("Área: ${area(forma)}")

Las variantes pueden llevar datos y casos te obliga a cubrirlas todas. Si agregas una forma nueva, el compilador te avisa.

usuarios.cometa

tipo Usuario
	nombre cadena
	mascota cadena?

enum ErrorCarga
	NoExiste
	Detalle cadena

fn cargar(id entero) Usuario!ErrorCarga
	si id == 0 retornar .Error(.NoExiste)
	Usuario {nombre: "Luis", mascota: "Michi"}

fn presentar(id entero) cadena!ErrorCarga
	// intentar propaga el error hacia quien llama.
	var usuario = intentar cargar(id)
	var mascota = usuario.mascota o "ninguna"
	"${usuario.nombre} (mascota: ${mascota})"

fn inicio()
	var texto = presentar(0) atrapar |error|
		casos error |detalle|
			.NoExiste => "no encontrado"
			.Detalle => detalle
	imprimir(texto)

Los errores son valores con tipo. Propágalos con intentar, atrápalos con atrapar o da un valor por defecto con o.

planetas.cometa

// Las interfaces se cumplen solo con tener los métodos.
interfaz Describible
	fn describir() cadena

tipo Planeta
	nombre cadena
	lunas entero
	pub fn describir() cadena "${@nombre} tiene ${@lunas} lunas"

tipo Caja<T>
	valor T
	pub fn obtener() T @valor

fn anunciar<T Describible>(cosa T) cadena
	"📡 " + cosa.describir()

fn inicio()
	var caja = Caja<Planeta> {valor: Planeta {nombre: "Júpiter", lunas: 95}}
	imprimir(anunciar(caja.obtener()))

Interfaces estructurales y genéricos con restricciones, como en los lenguajes modernos, escritos en español.

mapas.cometa

fn inicio()
	var puntos [cadena: entero] = [:]
	puntos["Ana"] = 10
	puntos["Luis"] = 20

	// Leer devuelve un opcional: decide qué hacer si falta.
	imprimir(puntos["Ana"] o 0)
	imprimir(puntos["Sofía"] o 0)

	repetir (puntos) |valor, clave|
		imprimir("${clave}: ${valor} puntos")

	var capitales = ["México": "CDMX", "Perú": "Lima"]
	imprimir(capitales.contiene("Perú"))

Diccionarios con [clave: valor]. Leer devuelve un opcional, así que siempre decides qué pasa si falta una clave.

// para todos

Para quien empieza y para quien ya programa.

🎒 Para aprender

Un primer lenguaje en tu propio idioma.

Palabras clave en español que se leen como instrucciones.
Mensajes de error claros que señalan la línea exacta.
Bloques con tabulaciones, sin llaves ni puntos y comas.
Haz un juego en tu primera tarde y ve tu código moverse.

🚀 Para expertos

Con las ideas de los lenguajes modernos.

Genéricos con restricciones, como fn describir<T Describible>.
Interfaces estructurales, enums con datos y casos exhaustivo.
Módulos con usar, visibilidad pub y biblioteca estándar.
Compila a Go y produce ejecutables nativos y rápidos.

// programar a mano

Programar a mano es divertido.

Programar se disfruta como tocar un instrumento o armar un rompecabezas, porque el gusto está en hacerlo por tu cuenta. Las herramientas pueden escribir código, pero ver funcionar una idea que escribiste línea por línea se siente distinto.

mi_idea.cometa

// Tu idea, escrita por ti, línea por línea.
fn estrellas(cantidad entero) cadena
	var texto = ""
	repetir (0..cantidad) |i|
		texto = texto + "★"
	texto

fn inicio()
	repetir (1..4) |nivel|
		imprimir("Nivel ${nivel}: ${estrellas(nivel)}")
	imprimir("¡Lo hice yo! 🎉")

Nivel 1: ★
Nivel 2: ★★
Nivel 3: ★★★¡Lo hice yo! 🎉

Es un juego
Cada error es un acertijo por resolver, y cuando lo resuelves se siente como ganar un nivel.
El momento de "¡funciona!"
Da mucha alegría ejecutar algo que construiste y ver que hace lo que imaginaste.
Entiendes lo que hiciste
Cuando lo escribes, sabes por qué funciona, y por eso después puedes cambiarlo o arreglarlo.
Es creativo
Un mismo problema se puede resolver de muchas formas, y tu código termina con tu estilo, como un dibujo o una canción.

Cometa está hecho para que escribir código se sienta como jugar.

Escribe tu primera línea

// pincel

Aprende jugando.

Pincel es la biblioteca de juegos 2D de Cometa. Implementa actualizar y pintar, llama a pincel.ejecutar y ya tienes una ventana con tu juego, sin configurar nada ni agregar otros archivos.

std/pincel
std/pincel/graficos
std/pincel/entrada
std/pincel/audio
std/pincel/recursos
std/pincel/tiempo
std/pincel/retro

Si todavía no tienes dibujos, el módulo retro incluye fuentes pixeladas e íconos de fantasía. Con pixelado = verdadero el juego se ve nítido, con estilo de 8 bits.

Pesadilla, una demo hecha con Cometa y Pincel.Ver el código en GitHub

mi_juego.cometa

usar std/mate
usar std/pincel
usar std/pincel/graficos
usar std/pincel/entrada

tipo Partida
	pos mate.Vec2

	pub fn actualizar(dt decimal)
		var direccion = mate.Vec2 {}
		si entrada.tecla_mantenida(.Derecha)
			direccion.x = 1
		si entrada.tecla_mantenida(.Izquierda)
			direccion.x = -1
		@pos = @pos + direccion * 120 * dt

	pub fn pintar()
		graficos.limpiar(.Negro)
		graficos.rectangulo_v(@pos, {16, 16}, .Amarillo)

fn inicio()
	pincel.ejecutar(Partida {pos: {x: 150, y: 80}}, titulo = "Mi cometa") atrapar |error|
		imprimir(error)

// empezar

Despega en tres pasos.

Instala la extensión de VS Code para tener resaltado, errores en vivo y autocompletado mientras escribes. Los pasos están en la guía para empezar.

1
Instala Cometa
Descarga cometa para tu sistema y ponlo en tu PATH. Necesitas además Go 1.25+, que Cometa usa para compilar tus programas.
```
cometa --version
```
2
Escribe y ejecuta
Crea un proyecto con tu primer programa y ejecútalo directamente.
```
cometa nuevo hola
cd hola
cometa ejecutar principal.cometa
```

Compártelo

Genera un ejecutable nativo, o mira el código Go que produce Cometa.

cometa construir hola.cometa -o hola.exe
cometa compilar hola.cometa -o hola.go

¿Listo para escribir tu primera línea en español?

Descargar Ver en GitHub Hacer el tour Biblioteca estándar

// apoyar

Impulsa a Cometa.

Cometa es un proyecto independiente. Si quieres patrocinarlo, hacer una donación o trabajar conmigo, escríbeme por correo.

Patrocinios y donaciones
Tu apoyo financia el trabajo en el compilador, la documentación y los ejemplos.
Escribir
Consultorías
Si quieres usar Cometa en un proyecto, un curso o una institución, escríbeme y conversamos sobre lo que necesitas.
Escribir
Material educativo
Solicita guías, ejercicios o material a la medida para enseñar a programar en español.
Escribir

Para cualquier otra consulta: crsolver@proton.me

Programa en tu idioma.

Fácil para empezar.Potente para crecer.

Sintaxis en español

Tipos

Sin nulos

Programas rápidos

Juegos 2D incluidos

El editor te ayuda

Así se escribe en Cometa.

Para quien empieza y para quien ya programa.

Un primer lenguaje en tu propio idioma.

Con las ideas de los lenguajes modernos.

Programar a mano es divertido.

Es un juego

El momento de "¡funciona!"

Entiendes lo que hiciste

Es creativo

Aprende jugando.

Despega en tres pasos.

Instala Cometa

Escribe y ejecuta

Compártelo

¿Listo para escribir tu primera línea en español?

Impulsa a Cometa.

Patrocinios y donaciones

Consultorías

Material educativo

Fácil para empezar.
Potente para crecer.