Instalación

Kmila funciona de tres formas: en el navegador en este sitio (sin instalar nada), auto-hospedada (la versión web en tu propia máquina o servidor) o como aplicación nativa. La versión web es Kmila.Web —una app Blazor Server sobre .NET 9— y comparte su código base con la aplicación nativa.

Código próximamente. Kmila es de código abierto (MIT), pero los repositorios públicos aún se están preparando para el lanzamiento de la v1.0. Los comandos siguientes usan las URLs finales de los repositorios; mientras no sean públicos, puedes apuntar las herramientas a otra fuente con la variable de entorno KMILA_REPO_BASE.

Opción A — Pruébala en el navegador

La forma más rápida: abre el demo y empieza a editar y simular — sin cuenta y sin instalar nada. Ejecuta todo el conjunto de herramientas de Kmila por completo en tu navegador (compilado a WebAssembly), así que tu código nunca sale de tu equipo.

La primera carga descarga el motor (unos segundos). Tu trabajo se guarda localmente en tu navegador (IndexedDB): permanece en este dispositivo y no se sincroniza. Para un uso ilimitado y persistente, instala la app nativa o auto-hospeda (más abajo). Consulta Privacidad.

Requisitos previos (para auto-hospedar)

Para	Necesitas
Obtener el código (siempre)	git
Compilación nativa	SDK de .NET 9 (`brew install dotnet-sdk`, o el instalador oficial; en Linux además `libicu`)
Compilación con Docker	Docker + Compose

El código de Kmila está repartido en seis repositorios —Kmila, Interpreter, Parser, Debugger, LibraryCompiler, TimeMachine— que deben estar uno junto a otro en un mismo espacio de trabajo, así que un solo clon no basta para compilar. Los scripts de abajo se encargan de esto por ti.

Opción B — Un solo comando (recomendado)

Los scripts de compilación están en el repositorio Kmila (App/Kmila/). Clonan los seis repositorios en un espacio de trabajo autónomo, fuerzan el target net9.0 (así no hace falta ningún workload de MAUI) y compilan.

# macOS / Linux / Windows (Git Bash o WSL)
./build.sh                 # compilación nativa (necesita el SDK de .NET 9)
./build.sh --docker        # construye la imagen de Docker (necesita Docker)
./build.sh --native --run  # compila y sirve en http://localhost:8080
# opciones: --workdir <dir>  --port <n>  --branch <b>   (env: KMILA_REPO_BASE)

# Windows (PowerShell)
./build.ps1                # -Mode native (por defecto) | -Mode docker ; -Run ; -WorkDir ; -Port

Linux, como servicio. install.sh (con sudo) instala las dependencias, compila y registra un servicio systemd en el puerto 8080:

sudo ./install.sh              # nativo + servicio systemd
sudo ./install.sh --docker     # contenedor de Docker en su lugar
sudo ./install.sh --no-service # solo instala dependencias y compila
# → http://<host>:8080 ; gestiona con: systemctl {status|restart|stop} kmila

Opción C — Compilación manual

Si prefieres no usar los scripts, esto es exactamente lo que hacen.

1. Clona los seis repositorios en la disposición requerida (el repo Kmila va en App/Kmila; sus proyectos referencian a los demás vía ../../../<nombre>):

mkdir kmila-build && cd kmila-build
for r in Interpreter Parser Debugger LibraryCompiler TimeMachine; do
  git clone https://github.com/Kmila9s/$r.git "$r"
done
git clone https://github.com/Kmila9s/Kmila.git App/Kmila

2a. Nativo — publica el .csproj (nunca el .sln, que arrastra la cabecera MAUI), forzando net9.0:

dotnet publish App/Kmila/Kmila.Web/Kmila.Web.csproj \
  -c Release -f net9.0 -p:TargetFrameworks=net9.0 -o publish
ASPNETCORE_URLS=http://+:8080 dotnet publish/Kmila.Web.dll   # → http://localhost:8080

2b. Docker — el contexto de build debe ser la raíz del espacio de trabajo; copia la receta desde deploy/:

cp App/Kmila/deploy/Dockerfile App/Kmila/deploy/.dockerignore App/Kmila/deploy/docker-compose.yml .
docker build -t kmila-web .
docker compose up -d          # → http://localhost:8080  (logs: docker compose logs -f)
docker compose down           # detener (datos conservados); añade -v para borrar el volumen

Opción D — Aplicación nativa

Las compilaciones nativas para Windows, macOS, Android e iOS se distribuyen desde el repositorio del proyecto y las tiendas de aplicaciones. Consulta la página de Descargas: las versiones para tiendas móviles llegan próximamente.

Configuración y datos

Puerto / enlace: ASPNETCORE_URLS (p. ej. http://+:8080); Docker lo mapea con ports: en el compose.
Dónde viven tus datos (base SQLite, paquetes de FPGA/diccionarios/librerías importados, caché de librerías compiladas):
- nativo: ~/.config/KmilaData (Linux), ~/Library/Application Support/KmilaData (macOS), %APPDATA%\KmilaData (Windows).
- Docker: el volumen nombrado kmila-data en /data —sobrevive a reinicios y recompilaciones; bórralo con docker compose down -v.
Detrás de HTTPS: Blazor Server necesita un WebSocket persistente (SignalR), así que tu proxy inverso debe permitir upgrades de WebSocket. Termina el TLS en el proxy y define ASPNETCORE_FORWARDEDHEADERS_ENABLED=true.

Solución de problemas

NETSDK1147 … workloads must be installed: android (o ios/maccatalyst) — no forzaste un solo framework. Añade -f net9.0 -p:TargetFrameworks=net9.0 y publica el .csproj, nunca el .sln.
El clon falla / pide credenciales — los repositorios son privados hasta el lanzamiento público; usa KMILA_REPO_BASE para apuntar a una fuente que puedas alcanzar.
Puerto en uso — cambia ASPNETCORE_URLS / --port (nativo) o el mapeo ports: del compose.
Página en blanco / desconexiones tras un proxy — se están descartando los WebSockets; habilita los upgrades de WS y ASPNETCORE_FORWARDEDHEADERS_ENABLED=true.

Consulta la guía de Primeros pasos para tu primer proyecto.