Hola mundo en Kotlin: con Android Studio y sin él
Un hola mundo en Kotlin es el programa más pequeño posible: solo muestra un saludo. Aquí lo hacemos de dos formas. Primero, con Android Studio, como una app que muestra «¡Hola, mundo!» en el emulador. Después, sin Android, como un programa de consola con fun main().
Es poca cosa, pero sirve para comprobar que todo funciona (Android Studio, el emulador y el proyecto, o el compilador de Kotlin) antes de escribir algo más serio.
Es como probar el micrófono antes de una charla: todavía no dices nada, pero con un «probando, probando» sabes que se oye.
Hola mundo en Android Studio, paso a paso
- Crea un proyecto nuevo.
- Elige la plantilla Empty Activity.
- Ponle nombre y elige la versión mínima de Android.
- Cambia el texto del saludo.
- Ejecútalo en el emulador.
1. Crea un proyecto nuevo
Abre Android Studio. Si no tienes ningún proyecto abierto, pulsa New Project en la pantalla de bienvenida. Si ya tienes uno abierto, ve a File → New → New Project.
2. Elige la plantilla Empty Activity
En la pestaña Phone and Tablet, elige Empty Activity y pulsa Next.
Una plantilla es un proyecto de partida con el código mínimo ya escrito. Empty Activity crea una app con una sola pantalla que muestra «Hello Android!». Hoy es la plantilla recomendada para cualquier proyecto nuevo y ya incluye Jetpack Compose.
3. Ponle nombre y elige la versión mínima
Rellena estos campos:
| Campo | Qué poner |
|---|---|
| Name | El nombre de tu app, por ejemplo HolaMundo. |
| Package name | Un identificador único, al revés que un dominio: com.tudominio.holamundo. Sustituye al antiguo campo «Company domain». |
| Save location | La carpeta donde se guardará el proyecto. |
| Language | Kotlin. Es el recomendado y el que necesita Compose. |
| Minimum SDK | La versión de Android más antigua en la que funcionará tu app. La documentación lo llama Minimum API level. |
¿Qué versión mínima elijo? Funciona como un balance:
- Una versión más antigua llega a más móviles.
- Una versión más nueva te deja usar más funciones modernas de Android, pero deja fuera los móviles que no se han actualizado.
Si dudas, pulsa Help me choose: Android Studio te muestra qué porcentaje de móviles Android cubres con cada versión mínima. Para un Hola mundo, deja la que viene propuesta. El curso oficial de Google usa API 24: Android 7.0 (Nougat).
Pulsa Finish y espera. La primera vez, Android Studio descarga dependencias y sincroniza Gradle (la herramienta que compila el proyecto), y puede tardar unos minutos.
4. Mira el código y cambia el saludo
Abre MainActivity.kt. Esto es lo que genera la plantilla (con com.tudominio.holamundo como paquete y HolaMundoTheme como tema, que Android Studio nombra a partir de tu proyecto):
package com.tudominio.holamundo
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.tudominio.holamundo.ui.theme.HolaMundoTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent {
HolaMundoTheme {
Scaffold( modifier = Modifier.fillMaxSize() ) { innerPadding ->
Greeting(
name = "Android",
modifier = Modifier.padding(innerPadding)
)
}
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
HolaMundoTheme {
Greeting("Android")
}
}
Leído de arriba abajo:
MainActivityes la pantalla de tu app. Una activity es cada pantalla que el usuario puede abrir. Android llama aonCreateal crearla; si quieres saber qué pasa después, se explica en Ciclo de vida de Activities en Android.enableEdgeToEdge()hace que la app ocupe toda la pantalla, también detrás de las barras del sistema (la de estado y la de navegación).setContent { … }dice qué se dibuja. Aquí entra Compose.Scaffoldes el armazón de la pantalla. SuinnerPaddinges el margen que dejan libre las barras del sistema, para que el texto no quede debajo.Greetinges una función composable (marcada con@Composable): una función de Kotlin que dibuja algo en pantalla. Esta dibuja unText.GreetingPreviewsirve para ver el resultado en Android Studio sin arrancar el emulador.
Para tu Hola mundo, cambia dos cosas: el texto del saludo y el nombre al que saluda.
Greeting(
name = "mundo",
modifier = Modifier.padding(innerPadding)
)
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "¡Hola, $name!",
modifier = modifier
)
}
$name mete el valor de la variable dentro del texto, así que la pantalla mostrará «¡Hola, mundo!». Si quieres repasar cómo funcionan las variables y los textos en Kotlin, tienes Variables y tipos en Kotlin.
Para verlo sin emulador: pulsa Split (arriba a la derecha) para ver el código y el diseño a la vez. Si la vista previa está vacía o no se actualiza, pulsa Build & Refresh.
5. Ejecútalo en el emulador
El emulador es un móvil Android virtual que corre en tu ordenador. Si aún no tienes uno:
- Con el proyecto abierto, ve a View → Tool Windows → Device Manager. Desde la pantalla de bienvenida, está en More Actions → Virtual Device Manager.
- Pulsa + y después Create Virtual Device. Elige un teléfono (por ejemplo, un Pixel) y pulsa Next.
- Elige una imagen del sistema de la pestaña Recommended y pulsa Next. Si tiene un icono de descarga al lado, descárgala primero.
- Revisa la configuración y pulsa Finish.
Después, elige el dispositivo en el desplegable de la barra superior y pulsa el botón verde de Run (el triángulo de play). La primera vez el emulador puede tardar varios minutos en arrancar. Cuando lo haga, verás tu «¡Hola, mundo!». Si usas Linux y el emulador no arranca por falta de permisos en /dev/kvm, sigue la solución al fallo de KVM en Ubuntu.
Un Hola mundo no enseña a programar: comprueba que todo está listo para empezar.
Qué hay dentro del proyecto
Android Studio muestra el proyecto en la vista Android, que agrupa los ficheros por tipo y no por carpeta real. Lo que te interesa al empezar:
| Dónde | Qué es |
|---|---|
app → manifests → AndroidManifest.xml |
La ficha de la app: su nombre, su icono y qué pantallas tiene. |
app → java → com.tudominio.holamundo → MainActivity.kt |
Tu código Kotlin, organizado por paquetes. |
… → ui.theme → Color.kt, Theme.kt, Type.kt |
El tema de la app: colores, estilo general y tipografía. |
app → res |
Recursos que no son código: textos, iconos e imágenes. |
Gradle Scripts |
Los ficheros build.gradle.kts que dicen cómo se compila la app y qué librerías usa. |
Para ver las carpetas tal como están en el disco, cambia la vista de Android a Project en el desplegable de arriba del panel.
Hola mundo en Kotlin sin Android: fun main()
Kotlin no es solo para Android. También sirve para programas de consola, servidores o scripts, y ahí el hola mundo es mucho más corto. Si solo quieres probar el lenguaje, no necesitas Android Studio ni un emulador.
Es como aprender a conducir en un descampado antes de salir a la carretera: el mismo coche, sin tráfico alrededor.
Crea un fichero llamado Hola.kt con esto:
fun main() {
println("¡Hola, mundo!")
}
Línea a línea:
fundeclara una función.maines el punto de entrada: la función por la que empieza a ejecutarse el programa. Tiene que llamarse así, en minúscula.printlnescribe el texto en la consola y salta de línea. Su hermanaprintescribe sin saltar.
Si vienes de Java, fíjate en lo que falta: no hay clase, ni public static void, ni punto y coma. En Kotlin, main puede vivir suelta en el fichero. Tienes más diferencias en Ventajas de Kotlin sobre Java.
Cómo ejecutarlo
La forma más rápida es el Kotlin Playground, el editor oficial en el navegador: pegas el código, pulsas Run y ves la salida. No instalas nada.
Desde el terminal necesitas Java (cualquier JDK actual) y el compilador de Kotlin, kotlinc. La documentación oficial propone dos formas de instalarlo en Linux:
- Descargar el zip
kotlin-compiler-<versión>.zipde las versiones de Kotlin en GitHub, descomprimirlo y añadir la carpetakotlinc/binalPATH. - Con SDKMAN!:
sdk install kotlin.
Con kotlinc instalado, compila el fichero a un .jar y ejecútalo con Java:
kotlinc Hola.kt -include-runtime -d hola.jar
java -jar hola.jar
¡Hola, mundo!
Qué hace cada opción:
-d hola.jarindica dónde dejar el resultado; aquí, un fichero.jar.-include-runtimemete dentro del.jarla biblioteca estándar de Kotlin, para que Java pueda ejecutarlo sin nada más.
Saludar a quien quieras
main también puede recibir los argumentos que escribes después del comando. Guarda esto como Saludo.kt:
fun main(args: Array<String>) {
val nombre = args.firstOrNull() ?: "mundo"
println("¡Hola, $nombre!")
}
argses la lista de argumentos.firstOrNull()toma el primero, onullsi no hay ninguno.?:(el operador Elvis) dice qué usar si lo de la izquierda esnull: en este caso,"mundo".
kotlinc Saludo.kt -include-runtime -d saludo.jar
java -jar saludo.jar
java -jar saludo.jar Ana
¡Hola, mundo!
¡Hola, Ana!
Errores típicos
Olvidar -include-runtime. Sin esa opción, el .jar no lleva la biblioteca estándar de Kotlin. El hola mundo más simple puede funcionar igualmente, porque println con un texto fijo apenas la usa, pero Saludo.kt falla al arrancar:
kotlinc Saludo.kt -d saludo.jar
java -jar saludo.jar Ana
Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics
at SaludoKt.main(Saludo.kt)
Caused by: java.lang.ClassNotFoundException: kotlin.jvm.internal.Intrinsics
Si ves NoClassDefFoundError con algo que empieza por kotlin/, vuelve a compilar con -include-runtime.
Escribir Main con mayúscula. Compila sin quejarse, porque Main es un nombre de función válido, pero ya no es el punto de entrada. Java no encuentra por dónde empezar. Con este Main.kt:
fun Main() {
println("¡Hola, mundo!")
}
kotlinc Main.kt -include-runtime -d m.jar
java -jar m.jar
no main manifest attribute, in m.jar
Buscar la clase Hola. Aunque no escribas ninguna clase, Kotlin genera una por debajo con el nombre del fichero más Kt. Por eso, si ejecutas con java -cp en lugar de java -jar, la clase se llama HolaKt:
java -cp hola.jar HolaKt
¡Hola, mundo!
Probado el 8 de noviembre de 2026 con Kotlin 2.4.21 (kotlinc-jvm 2.4.21) y Java 25.0.5 (Eclipse Temurin), en un contenedor eclipse-temurin:25 con el zip oficial del compilador.
Así era en 2018: con vistas XML
En la versión original de este artículo (2018), el asistente era distinto: había que indicar un «Company domain», marcar Include Kotlin Support y, al final, la casilla Backwards Compatibility (AppCompat) para dar soporte a versiones antiguas. Hoy Kotlin viene por defecto y las librerías AndroidX sustituyen a aquellas librerías de compatibilidad.
El proyecto se creaba con dos archivos: uno con el código Kotlin y otro, en XML, con la vista del Hola Mundo. Este era el MainActivity.kt:
package com.rubentejera.holamundo
// import ... (los imports, plegados en el editor)
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
setContentView(R.layout.activity_main) cargaba la pantalla desde el fichero activity_main.xml. Con Compose, setContent { … } la describe directamente en Kotlin. Si mantienes un proyecto antiguo o quieres aprender con XML, usa la plantilla Empty Views Activity: sigue existiendo.
Al darle al play, el emulador mostraba esto:
Siguiente paso
- Cambia el texto de
Greetingy mira cómo se actualiza la vista previa. - Añade un segundo
Textdebajo del primero y descubre por qué hace falta un contenedor comoColumn. - Si Kotlin es nuevo para ti, empieza por ¿Qué es Kotlin? y practica el lenguaje con los Koans de Kotlin.
- Para añadir un botón que responda al toque, sigue con Eventos click en Android.
- Si quieres entender qué hace Gradle cuando pulsas Run, lo explicamos en Qué es Gradle en Android Studio.
Fuentes
Parte de Android, comprobada el 8 de noviembre de 2026 en la documentación oficial de Android:
- Create a project: pasos del asistente, plantilla Empty Activity recomendada, Kotlin como lenguaje recomendado, Minimum SDK y Help me choose, y AndroidX por defecto.
- Create your first Android app (Android Basics with Compose): flujo del proyecto, API 24 como mínimo, vista Split y Build & Refresh.
- Run your first app on the Android Emulator: creación del dispositivo virtual y ejecución.
- Create and manage virtual devices: cómo abrir el Device Manager, crear el dispositivo y la pestaña Recommended de imágenes del sistema.
- Projects overview: estructura del proyecto en las vistas Android y Project.
- Set up edge-to-edge: qué hace
enableEdgeToEdge()y por qué se usa elinnerPaddingdelScaffold. - Código de
MainActivity.kt: copiado de la plantilla oficial de Android Studio en el código fuente de AOSP (ramamirror-goog-studio-main, plantilla «Empty Activity»), sustituyendo solo el paquete y el nombre del tema. - Versión estable de Android Studio en esa fecha, según su página de versiones: Android Studio Rabbit 2 (2026.2.2 Patch 1).
Parte de Kotlin sin Android, comprobada el 8 de noviembre de 2026:
- Kotlin command-line compiler (kotlinlang.org): instalación con el zip de GitHub o SDKMAN!,
kotlinccon-include-runtimey-d, yjava -jar. La página apunta a la versión 2.4.21. - Basic syntax: program entry point (kotlinlang.org): las dos formas de
main,printyprintln. - Kotlin 2.4.21 en GitHub: última versión estable en esa fecha.
La parte de Android: el código de la app no se ha compilado ni ejecutado en esta revisión, porque no había un entorno Android disponible; se ha contrastado con la documentación y con la plantilla oficial. El código de Kotlin sin Android sí se ha ejecutado, con las versiones indicadas en su sección. El código y la captura de 2018 son de Rubén, con la versión de Android Studio de entonces.