Comparativa entre Go, Odin y Rust

En esta ocasión veremos una comparativa entre tres lenguajes de programación modernos: Go, Odin y Rust.

Comencemos observando esta tabla comparativa.

Comparativa entre lenguajes.

Característica	Go	Odin	Rust
Creador	Ken Thompson, Robert Pike y Robert Griesemer	Ginger Bill	Graydon Hoare
Paradigma	Multiparadigma	Multiparadigma (con limitantes) y orientado a datos	Multiparadigma (con limitantes)
Extensión	.go	.odin	.rs
Tipado	Estático	Estático	Estático
Nivel de abstracción	Alto nivel	Alto nivel	Alto nivel
Tipo de ejecución	Compilado	Compilado	Compilado
Ideal para	Microservicios, aplicaciones concurrentes, etc.	Para sistemas de alto rendimiento, etc.	Aplicaciones cliente-servidor, aplicaciones concurrentes, etc.

Los tres lenguajes comparten algo en común: todos pretenden ser una mejora del lenguaje C. Empecemos entonces está comparativa.

Comparativa entre lenguajes (Go, Odin y Rust)

1. Creación de proyectos. Veremos cómo crear proyectos en estos lenguajes.

Go:

$ mkdir nombre-proyecto
$ cd nombre-proyecto
$ go mod init ejemplo.com/nombre-proyecto

Go (con Go-blueprint):

$ go-blueprint create --name nombre-proyecto

Odin:

$ mkdir proyecto-odin
$ cd proyecto-odin
$ touch main.odin

Rust:

$ cargo new nombre-proyecto

Como se puede observar, con Odin no es necesario contar con una estructura compleja.

2. Compilación. Los tres lenguajes son compilados. Veremos las instrucciones de compilación.

Go:

$ go build

Odin:

$ odin build programa.odin -file

Rust (con Cargo):

$ cargo build

3. Ejecución.

Go (con un proyecto):

$ go run

Go (sin proyecto): al cosntruir se crea un ejecutable.

$ .\main.exe

Odin: al compilar el código .odin se creará un ejecutable.

$ .\main.exe

Rust:

$ cargo run

4. Primer programa. Crearemos el clásico "Hola, mundo".

Go:

main.go

package main

import "fmt"

func main() {
   fmt.Println("Hola, mundo")
}

Odin:

main.odin

package main

import "core:fmt"

main :: proc(){
    fmt.println("Hola, mundo");
}

Rust:

main.rs

fn main() {
    println!("¡Hola, mundo!");
}

Como se puede observar los más parecidos son Go y Odin. Miremos ahora los tipos de datos.

5. Tipos de datos. Al ser lenguajes de tipado estático debemos conocer que tipo de datos básicos pueden manejar.

Go:

# Enteros
int, int8, int16, int32, int64

# Enteros sin signo.
uint, uint8, uint16, uint32, uint64, uintptr

# Para números decimales, siendo float64 el estándar.
float32, float64

# Números complejos.
complex64, complex128

# Alias de uint8.
byte

# Alias de int32, representa un punto de código Unicode.
rune

# Cadenas
string

# Booleanos: true y false
bool

Odin:

# Enteros con signo: 
int, i8, i16, i32, i64, i128.
# Sin signo: 
uint, u8, u16, u32, u64, u128.
# Coma Flotante (Floats): 
f16, f32, f64.
# Booleanos: 
bool 
# Cadenas de texto (String): 
string
# Unicode
rune

Rust:

# Enteros con signo: 
i8-i128, isize
# Sin signo: 
u8-u128, usize
# Coma Flotante: 
f32,  f64
# Booleanos: 
bool 
# Caracteres:
char

Programando en Go, Odin y Rust

Crearemos un programa que sume los primeros 20000 que sean divisibles entre 3 y 5.

Go:

main.go

package main

import "fmt"

func main() {
	const MAX = 20000
	var suma int = 0
	fmt.Printf("Suma inicial: %d\n", suma)
	for i := 0; i < MAX; i++ {
		if i%3==0 && i%5== 0{
			suma+=i
		}
	}
	fmt.Printf("Suma final: %d\n", suma)
}

Compilación y ejecución:

$ go build
$ .\main.exe

Salida:

Suma inicial: 0
Suma final: 13336665

Odin:

main.odin

package fundamemtos

import "core:fmt"

main :: proc(){
    suma: int = 0;
    CONST_MAX :: 20000
	
    fmt.printfln("Suma inicial: %d", suma);
	
	for i in 0..< CONST_MAX { 
	   if i%3==0 && i%5==0 {
		 suma = suma + i;
	   }
	}
	
    fmt.printfln("Suma final: %d", suma);
}

Compilación y ejecución:

$ odin build main.odin -file
$ .\main.exe

Salida:

Suma inicial: 0
Suma final: 13336665

Rust:

main.rs

fn main() {
	const  MAX: i64 = 20000;
	let mut suma: i64 = 0;
	println!("Suma inicial: {}", suma);
	for i in 0..MAX {
        if i % 3 == 0 && i % 5 == 0 {
		suma+=i;
		}
	}
	println!("Suma final: {}", suma);
}

Compilación y ejecución:

$ cargo build
$ cargo run

Salida:

Suma inicial: 0
Suma final: 13336665

Rendimiento:

El programa hecho en Odin fue más rápido en compilación y ejecución con respecto al código hecho en Go y Rust.

Odin es un lenguaje relativamente nuevo que toma lo mejor de lenguajes como C y C++ para crear software robusto.

Go es un lenguaje que ha adquirido mucha relevancia para el desarrollo de microservicios y tiene hacia arriba en la elección

Rust, al igual que Go, ha adquirido mucha relevancia debido a que cada vez es más necesario el desarrollo de aplicaciones concurrentes y robustas.

Continuaremos con esta serie sobre lenguajes de programación.

Enlaces:

https://alquimistadecodigo.blogspot.com/2025/03/comparativa-entre-odin-y-c.html
https://www.reddit.com/r/programming/comments/12xo53v/ginger_bill_interview_creator_of_the_odin_language/?tl=es-419
https://alquimistadecodigo.blogspot.com/2025/12/creando-proyectos-con-go.html
https://alquimistadecodigo.blogspot.com/2026/04/creando-proyectos-go-con-go-blueprint.html