aurora-ui 0.2.0

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

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), una sola ventana nativa 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.10, uv y Rust (rustup). En Linux también libfontconfig-dev y libfreetype-dev.

git clone https://github.com/<usuario>/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.

¿Prefieres pip? pip install maturin && maturin develop --release.

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 + softbuffer.

¿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, accesibilidad completa 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 (todo está en el roadmap):

• Render por CPU: suficiente para interfaces normales; el backend GPU está planificado.
• Reconstrucción completa: cada evento reconstruye la vista entera. Es barato en apps medianas; la reactividad de grano fino llega en la v0.3.
• Todavía sin canvas de dibujo libre, accesibilidad ni multi-ventana.

Documentación

• 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, studio.py 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.