aurora-ui 0.9.1

Interfaces de escritorio profesionales, rápidas y elegantes, escritas solo en Python.
Declarativas · Reactivas · Núcleo nativo en Rust · Sin WebView

Documentación · Inicio rápido · Guía · Referencia · Arquitectura · Visión · Roadmap

¿Qué es Aurora?

Aurora es una librería para construir aplicaciones de escritorio con interfaces de nivel profesional usando únicamente Python. Describes la interfaz como una función de tu estado; Aurora se encarga del resto con un motor nativo escrito en Rust: layout, tipografía, render, animaciones y eventos.

Nace de una frustración concreta: para que una app de escritorio en Python se vea bien, hoy lo habitual es montar React + WebView + un backend HTTP, o aceptar la estética de toolkits de otra época. Aurora apuesta por un camino distinto: una sola tecnología (Python), ventanas nativas de verdad y un aspecto moderno desde la primera línea.

from aurora import App, Signal, button, card, row, text

clicks = Signal(0)


def view():
    return card(padding=32, gap=16)[
        text(lambda: f"{clicks()} clicks", size=40, weight=800),
        row(gap=8)[
            button("Restar", lambda: clicks.update(lambda c: c - 1), variant="soft"),
            button("Sumar", lambda: clicks.update(lambda c: c + 1)),
        ],
    ]


App(view, title="Contador").run()

_{examples/studio.py: navegación, kanban con búsqueda, gráfico interactivo, formularios, ajustes, modal, toasts y tema claro/oscuro.
Todas las capturas del repositorio están renderizadas por la propia librería.}

Por qué Aurora

Inicio rápido

Requisitos: Python ≥ 3.11. En Linux, fontconfig y freetype (los traen casi todas las distribuciones; en Debian/Ubuntu son libfontconfig1 y libfreetype6).

pip install aurora-ui       # o, con uv: uv add aurora-ui

Los wheels incluyen el núcleo nativo ya compilado para Windows, macOS (x64 y arm64) y Linux x86_64, así que no necesitas Rust. Guarda esto como mi_app.py y ejecútalo con python mi_app.py:

from aurora import App, text

App(lambda: text("Hola, Aurora", size=32, weight=700), title="Mi app").run()

¿Vas a trabajar sobre el propio Aurora? Clona el repositorio; para eso sí hacen falta uv y Rust (rustup), y en Linux los paquetes de desarrollo (libfontconfig-dev y libfreetype-dev):

git clone https://github.com/YoshiLoL0526/aurora.git
cd aurora
uv sync                          # compila el núcleo Rust (release) e instala en modo editable
uv run examples/hello.py         # tu primera ventana
uv run examples/studio.py        # la demo completa

La primera compilación descarga binarios precompilados de Skia y tarda unos minutos. Después solo se recompila el crate propio, y únicamente cuando cambias código Rust.

En el repositorio también puedes usar pip en lugar de uv: pip install maturin && maturin develop --release.

Mientras desarrollas, arranca la app con hot reload: al guardar, la ventana se actualiza con el código nuevo sin perder el estado (ver hot reload):

aurora dev mi_app.py

Para repartir tu app, empaquétala en un ejecutable con un comando (requiere el extra aurora-ui[build]; ver empaquetado):

pip install "aurora-ui[build]"
aurora build mi_app.py --icon assets/icon.ico --include assets

Un vistazo a la API

from aurora import App, Signal, DAYLIGHT, MIDNIGHT, badge, button, card, column, row, spacer, stat, text

theme = Signal(MIDNIGHT)


def toggle_theme():
    theme.set(DAYLIGHT if theme() is MIDNIGHT else MIDNIGHT)


def header():
    return row(align="center", gap=12)[
        text("Panel", size=26, weight=700),
        badge("beta"),
        spacer(),  # empuja lo siguiente a la derecha
        button("Cambiar tema", toggle_theme, variant="ghost"),
    ]


def view():
    return column(padding=32, gap=24)[
        header(),
        row(gap=16)[
            stat("INGRESOS", "$48.2k", "+12%"),
            stat("PEDIDOS", "1.204", "+3%"),
            stat("DEVOLUCIONES", "2,1%", "+0,4", positive=False),
        ],
        card()[
            text("Últimos movimientos", size=15, weight=600),
            text("Una descripción larga que se corta con elipsis…", max_lines=1, color="$muted"),
        ],
    ]


App(view, title="Mi panel", size=(1100, 720), theme=theme).run()

La referencia completa de propiedades está en docs/reference.md.

Cómo funciona

 Tu código Python                              Núcleo nativo (Rust)
 ─────────────────                             ───────────────────────────────────────────
 view() ─► árbol de Element ─► to_spec() ──►   spec    dict → nodos tipados, herencia de estilos
     ▲                          (1 cruce)      layout  Taffy (flexbox) + medición de texto Skia
     │                                         paint   Skia: formas, sombras, gradientes, texto
     │                                         anim    hover/pressed, scroll suave, foco, tooltips
     │                                         input   edición de texto, IME, portapapeles
 Signal.set() ◄── callback ◄── evento ◄──────  window  winit + framebuffer; bucle sin el GIL

Python describe; Rust ejecuta. La frontera entre ambos se cruza una vez por actualización, con un árbol completo, en lugar de miles de llamadas pequeñas. Los detalles están en docs/architecture.md.

Stack: PyO3 + maturin · Skia (vía skia-safe) · Taffy · winit · GPU con Vulkan/Metal (vulkano) y softbuffer como respaldo por CPU.

¿Cuándo usar Aurora?

Aurora encaja cuando quieres una app de escritorio con aspecto moderno, escrita en Python, sin desarrollo web de por medio: dashboards, herramientas internas, paneles de control para tus scripts y modelos, utilidades personales.

Si hoy necesitas un toolkit maduro con cientos de widgets y años en producción, Qt (PySide6/PyQt) es la opción sensata. Si tu interfaz vive en el navegador, una solución web encaja mejor. Aurora no busca reemplazarlas: busca que construir una interfaz bonita y rápida desde Python sea lo más directo posible. Más contexto en VISION.md.

Limitaciones conocidas

Aurora es joven. Esto es lo que todavía no hace:

• Vista completa tras cada evento: un Signal que cambia desde un hilo o app.spawn y solo lee una región (text(lambda: ...), bg=lambda: ...) ya no vuelve a llamar a view(), pero tras un clic o una tecla la vista se reconstruye entera (los @component que no cambiaron se reutilizan). Y un cambio que mueve la geometría rehace el layout del árbol entero, con la caché de Taffy. En vistas de decenas de miles de nodos se nota; virtualiza las listas largas.
• Menús nativos y bandeja en Linux: los menús del sistema necesitan GTK, que Aurora no usa: en Linux la barra y los contextuales no aparecen, y ese hueco lo cubre el componente menu dentro de la app. La bandeja usa StatusNotifierItem: en GNOME necesita la extensión AppIndicator (y algunos escritorios no la muestran).
• Soltar archivos fuera de Windows: macOS y Linux (X11) no informan de dónde se sueltan, así que los archivos van al primer on_drop de la vista; en Wayland, winit aún no los entrega.

Documentación

Publicada en https://yoshilol0526.github.io/aurora/, con buscador, tema claro/oscuro y ejemplos vivos: cada captura se genera ejecutando el código que la acompaña.

• Guía: de cero a una app completa, paso a paso.
• Referencia: todas las primitivas, componentes y propiedades de estilo.
• Arquitectura: cómo funciona el núcleo y por qué está diseñado así.
• Visión y Roadmap: hacia dónde va el proyecto.
• Ejemplos: hello.py para empezar, studio.py como app completa, canvas.py, charts.py, table.py y animate.py por temas, y brand.py (genera el banner de este README).

Contribuir

Las contribuciones son bienvenidas, desde reportar un bug hasta implementar un widget. Lee CONTRIBUTING.md para preparar el entorno, conocer las convenciones y proponer cambios. Este proyecto sigue un Código de conducta.

Licencia

MIT © Raidel y contribuidores de Aurora.