lunaris

KO | EN

gitlite — search

#javascript #hacktoberfest #react #ai #typescript #rust #deep-learning #docker #macos #nodejs #windows #vue #security #open-source

(★ 9)

The modular multimedia engine of the future

lunaris 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Lunaris – a plugin-first video editor

> Rapid development: APIs and workflows may change frequently.

Lunaris is a node-based, GPU-accelerated video editor built around a microkernel architecture. The core runtime hosts a lightweight ECS (`lunaris_ecs`), a job orchestrator for CPU/GPU work, and an iced-based UI. Almost all functionality ships as plugins that are statically linked and auto-discovered at startup.

## Quick start

- Requirements: Rust toolchain with edition 2024 support (currently nightly), Cargo, GPU drivers for `wgpu`, and git with submodules enabled.
- Clone: `git clone --recurse-submodules <repo>`
- Install the developer wrapper (cargo-like UX): `cargo install --path tools/lunac`
- Run the app with the full runtime: `cargo run -p lunaris --features full`
  - Logging controls: `-v/--verbose`, `--log-level <error|warn|info|debug|trace>`, `--log-filter "<target>=<level>"`, `--color <auto|always|never>`. Default filter: `warn,lunaris=info,lunaris_core=info`.
  - Without `--features full`, the wrapper only sets up logging and exits with a helpful error.
- Build/test with `lunac` (mirrors cargo): `lunac build`, `lunac run`, `lunac check`, `lunac clippy`, `lunac test`. Pass extra cargo flags after `--`.

### Common workflows

- Fast dev loop: `lunac run -- --help` (forward CLI help), or `lunac run --release` for perf checks.
- Sync plugins after adding/removing crates: `lunac sync` (runs the linker updater for you).
- Manual linker refresh: `cargo run -p linker_updater -- crates/lunaris_linker/Cargo.toml plugins/`.
- Barebones/no-runtime build: `lunac build --barebones` (useful for validating the wrapper binary only).

## Workspace layout

- `bin/lunaris`: CLI wrapper that configures logging and launches the runtime when built with `--features full`.
- `crates/lunaris_core`: Host application (iced + `wgpu`) that initializes GPU state, spins up a world thread, and runs the plugin-driven UI. Uses `lunaris_linker` to force linking statically registered plugins.
- `crates/lunaris_api`: Public plugin surface—traits (`Plugin`, `Gui`, `Renderer`, `SystemPlugin`, `SystemContributor`), `PluginContext` (ECS `World` + orchestrator handle), render helpers (`render::init_gpu`, `RawImage`), async/sync job API (`request` with priorities), property bags, and registration macros.
- `crates/lunaris_ecs`: Thin abstraction over `bevy_ecs`, re-exporting minimal types and derive macros needed by plugins.
- `crates/lunaris_linker`: Build-time glue to ensure all inventory submissions are linked so the runtime can discover plugins.
- `plugins/core/*`: Built-in examples—`dummy` (skeleton), `profiler` (FPS + orchestrator controls), `timeline` (iced timeline mock), `video` (renderer backend stub with optional ffmpeg).
- `tools/lunac`: Developer helper that proxies common cargo commands to the Lunaris workspace; keeps the linker crate in sync.

## Architecture Overview

Lunaris uses a microkernel architecture where a minimal runtime hosts plugins that provide all functionality. The system is built around three main components: a dual-threaded execution model (UI + ECS World), a priority-aware job orchestrator, and a plugin system discovered at build time.

```
┌────────────────────────────────────────────────────────────────────┐
│                         Lunaris Application                        │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  ┌───────────────────┐         ┌──────────────────────────────┐    │
│  │   CLI Wrapper     │         │        lunaris_core          │    │
│  │   (bin/lunaris)   │────────▶│                              │    │
│  │                   │         │  ┌────────────────────────┐  │    │
│  │ - Parse args      │         │  │    UI Thread (iced)    │  │    │
│  │ - Setup logging   │         │  │  ┌──────────────────┐  │  │    │
│  │ - Init runtime    │         │  │  │  lunaris_ui      │  │  │    │
│  └───────────────────┘         │  │  │  (iced dispatch) │  │  │    │
│                                │  │  └────────┬─────────┘  │  │    │
│  ┌───────────────────┐         │  │           │            │  │    │
│  │   lunaris_api     │◀────────│  │           ▼            │  │    │
│  │                   │         │  │  ┌──────────────────┐  │  │    │
│  │ - Plugin traits   │         │  │  │ Plugin Panes     │  │  │    │
│  │ - PluginContext   │         │  │  │ Box<dyn Fn(ctx)> │  │  │    │
│  │ - Render helpers  │         │  │  └──────────────────┘  │  │    │
│  │ - Job API         │         │  └────────────────────────┘  │    │
│  └───────────────────┘         │                              │    │
│                                │  ┌────────────────────────┐  │    │
│  ┌───────────────────┐         │  │   World Thread (ECS)   │  │    │
│  │   lunaris_ecs     │◀────────│  │                        │  │    │
│  │                   │         │  │  - Schedule loop       │  │    │
│  │ - World           │         │  │  - Systems execution   │  │    │
│  │ - Schedule        │         │  │  - Resource mgmt       │  │    │
│  │ - bevy_ecs wrap   │         │  └────────────────────────┘  │    │
│  └───────────────────┘         │              │               │    │
│                                │              ▼               │    │
│  ┌───────────────────┐         │  ┌────────────────────────┐  │    │
│  │  lunaris_linker   │         │  │    Orchestrator        │  │    │
│  │                   │         │  │                        │  │    │
│  │ - Force plugin    │         │  │  - Worker pool         │  │    │
│  │   linking         │         │  │  - Priority queues     │  │    │
│  │ - Build-time glue │         │  │  - Async runtime       │  │    │
│  └───────────────────┘         │  └────────────────────────┘  │    │
│                                │                              │    │
│                                └──────────────────────────────┘    │
│                                                                    │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                   Plugins (statically linked)               │   │
│  ├─────────────────────────────────────────────────────────────┤   │
│  │  core/dummy  │  core/profiler  │  core/timeline  │  etc...  │   │
│  │  - Plugin    │  - Plugin       │  - Plugin       │          │   │
│  │  - Gui       │  - Gui          │  - Gui          │          │   │
│  │  - Renderer  │  - Renderer     │  - Renderer     │          │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘
```

### Threading and Concurrency

Lunaris uses a multi-threaded architecture with distinct responsibilities:

```
Main Thread (startup only)
    │
    ├─ Parse CLI args
    ├─ Init logging
    ├─ Create wgpu Device/Queue  ───────┐
    ├─ Call render::init_gpu()          │ Stored in static OnceLock
    ├─ Create ECS World                 │ Accessible from any thread
    └─ Launch eframe app                └─────────────────────────────▶
           │
           ├──────────────────────┬──────────────────────────┐
           │                      │                          │
           ▼                      ▼                          ▼
    ┌─────────────────┐   ┌──────────────────┐   ┌────────────────────────┐
    │  UI Thread      │   │  World Thread    │   │   Worker Pool          │
    │  (iced-based)   │   │  (ECS Schedule)  │   │   (Orchestrator)       │
    │                 │   │                  │   │                        │
    │  lunaris_ui     │   │  Loop @ ~60 FPS: │   │  Default Workers (N):  │
    │  ┌───────────┐  │   │                  │   │    ┌──────────────┐    │
    │  │ Pane Mgr  │  │   │  1. Poll cmds ◀──┼───┼────│ Priority     │    │
    │  └─────┬─────┘  │   │     (mpsc recv)  │   │    │ Queues:      │    │
    │        │        │   │                  │   │    │ - Immediate  │    │
    │        ▼        │   │  2. schedule.run │   │    │ - Normal     │    │
    │  ┌───────────┐  │   │     (&mut world) │   │    │ - Deferred   │    │
    │  │ Display   │  │   │                  │   │    └──────────────┘    │
    │  │ Plugin    │  │   │  3. Execute      │   │                        │
    │  │ Panes     │  │   │     systems      │   │  Frame Workers (M):    │
    │  └─────┬─────┘  │   │                  │   │    ┌──────────────┐    │
    │        │        │   │  4. Publish state│   │    │ VideoFrame   │    │
    │        ▼        │   │     (ArcSwap)────┼───┼───▶│ ArrayQueue   │    │
    │  Box<dyn Fn(    │   │                  │   │    │ (lock-free)  │    │
    │    ctx)> calls  │   │  5. Check quit   │   │    └──────────────┘    │
    │                 │   │                  │   │                        │
    │  ctx contains:  │   │  ┌────────────┐  │   │  Background Workers:   │
    │  - UI state     │◀──┼──│ Systems:   │  │   │    ┌──────────────┐    │
    │    snapshot     │   │  │ - Physics  │  │   │    │ VecDeque     │    │
    │  - Orch handle  │   │  │ - Audio    │  │   │    └──────────────┘    │
    │                 │   │  │ - Render   │  │   │                        │
    │  Send command   │   │  │ - Custom   │  │   │  Tokio Async Runtime:  │
    │  ───────────────┼──▶│  └────────────┘  │   │    ┌──────────────┐    │
    │   (mpsc send)   │   │                  │   │    │ 1-4 threads  │    │
    │                 │   │  Orchestrator    │   │    │ for async    │    │
    │                 │   │  (Resource)      │   │    │ futures      │    │
    │                 │   │  ┌────────────┐  │   │    └──────────────┘    │
    │                 │   │  │ Submit:    │  │   │                        │
    │                 │   │  │ - sync job │──┼───┼───▶│ Job execution │   │
    │                 │   │  │ - async job│  │   │                        │
    │                 │   │  │ - join_fg  │  │   │  Atomic Counters:      │
    │                 │   │  │            │  │   │  - fg_jobs (foreground)│
    │                 │   │  │ Publish:   │  │   │  - bg_jobs (background)│
    │                 │   │  │ - UI state │──┼───┼───▶ ArcSwap/RwLock     │
    │                 │   │  └────────────┘  │   │     per-plugin state   │
    └─────────────────┘   └──────────────────┘   └────────────────────────┘
         │                         │                        │
         └─────────────────────────┼────────────────────────┘
                                   │
                    Shared GPU State (OnceLock)
                    - wgpu::Device
                    - wgpu::Queue
```

**Key architectural decisions:**

- **UI Thread (iced)**: Manages the windowing system and plugin panes. `lunaris_ui` dispatches rendering to plugin callbacks (`Box<dyn Fn(ctx: ContextStorage)>`) based on which panes are visible. Plugins receive a context containing access to published UI state snapshots.
- **World Thread**: Runs the ECS schedule at ~60 FPS. Executes all registered systems, processes events, and updates resources. Publishes state snapshots for UI consumption via lock-free `ArcSwap` or `RwLock` storage. Receives commands from UI thread via `mpsc` channels.
- **State Publishing**: World thread can publish state updates that UI thread picks up via `UiStateContext` (backed by `ArcSwapStorage` for lock-free copy-on-write snapshots or `RwLockStorage` for in-place mutation). Each plugin maintains its own UI state context.
- **Orchestrator Worker Pool**: Priority-aware task scheduler with five priority levels (`Immediate`, `VideoFrame`, `Normal`, `Deferred`, `Background`). Each priority has dedicated worker threads and queues. Includes a Tokio async runtime for async/await tasks.
- **GPU State**: `wgpu` device and queue are initialized once at startup and stored in `OnceLock` statics. Any thread can access via `render::device()` and `render::queue()` helpers.

### Plugin System

Plugins are discovered at build time using the `inventory` crate and statically linked via `lunaris_linker`. Each plugin implements one or more traits:

- **`Plugin`**: Core interface with lifecycle methods (`new`, `init`, `update_world`, `report`, `shutdown`)
- **`Gui`**: UI rendering with `ui()` method that draws into panes managed by iced

The `export_plugin!` macro handles registration:

### Startup Sequence

The initialization process follows a strict order to ensure all components are ready before the main loop starts:

```
1. CLI Wrapper (bin/lunaris)
   ├─ Parse arguments (logging level, filters, colors)
   ├─ Apply environment variables (RUST_LOG, LUNARIS_COLOR)
   ├─ Initialize tracing subscriber
   └─ Call lunaris_core::run()

2. Runtime Initialization (lunaris_core)
   ├─ Register OS signal handlers (SIGTERM cleanup)
   ├─ Initialize GPU (wgpu)
   │  ├─ Create Instance
   │  ├─ Request adapter (HighPerformance)
   │  ├─ Request device with default descriptor
   │  └─ Store in OnceLock via render::init_gpu()
   ├─ Create empty ECS World
   └─ Launch eframe application

3. Application Setup (LunarisApp)
   ├─ Create mpsc channel for UI ↔ World communication
   ├─ Spawn World Thread
   │  ├─ Create World and Schedule
   │  ├─ Insert Orchestrator resource
   │  ├─ Initialize worker pool (default, frame, background)
   │  └─ Start schedule loop at ~60 FPS
   ├─ Plugin Discovery
   │  ├─ inventory::iter::<GuiRegistration>()
   │  ├─ Instantiate each plugin via Plugin::new()
   │  └─ Call plugin.init(InitContext)
   └─ Setup lunaris_ui (iced)
      ├─ Create pane tree structure
      ├─ Bind plugins to panes (pane_id → Box<dyn Fn(ctx)>)
      └─ Enter render loop

4. Main Loop (running)
   ├─ UI Thread: iced checks visible panes and calls plugin Fns
   └─ World Thread: schedule.run(&mut world) every ~16ms
```

The entire startup typically completes in under 100ms on modern hardware.

### Data Flow: User Interaction to Render

This example traces a complete flow from user input to GPU rendering:

```
1. User clicks button in timeline plugin pane
   │
   ▼
2. UI Thread (iced) calls plugin callback
   Box<dyn Fn(ctx: ContextStorage)>
   │
   ▼
3. Plugin accesses ctx.orch and submits job
   ctx.orch.submit_job_boxed(
       Box::new(|| decode_video_frame()),
       Priority::VideoFrame
   )
   │
   ▼
4. Orchestrator routes job to frame worker queue
   (lock-free ArrayQueue for VideoFrame priority)
   │
   ▼
5. Frame Worker thread executes job
   - Decodes video frame
   - Stores result in ECS World (Component/Resource)
   - Decrements fg_jobs atomic counter
   │
   ▼
6. World Thread schedule processes data
   - Render system queries frame data
   - Prepares RenderJob (Properties bag)
   - Calls renderer plugin: schedule_render(job)
   │
   ▼
7. Renderer Plugin executes on GPU
   - Accesses render::device() and render::queue()
   - Encodes wgpu commands
   - Submits to GPU queue
   │
   ▼
8. UI Thread next frame
   - iced checks displayed panes
   - Calls plugin Fn with updated context
   - Plugin draws to pane (shows decoded frame)
   - iced composites all panes to window
```

**Key flow patterns:**
- **UI → Job submission**: Plugins submit work via Orchestrator from UI thread
- **Job execution**: Worker pool executes jobs concurrently based on priority
- **ECS integration**: Results stored in World, processed by systems on World thread
- **State publishing**: World thread publishes state snapshots via `ArcSwap` (lock-free copy-on-write) or `RwLock` storage for UI consumption
- **UI updates**: UI thread reads published state snapshots via `ctx`, plugins render based on current state

## Plugin development

Plugins are regular Rust crates linked into the binary and discovered via `inventory`. The `lunaris_api::export_plugin!` macro handles registration and shares a single instance across all requested features (core plugin, GUI, renderer).

## Logging and diagnostics

- Default filter: `warn,lunaris=info,lunaris_core=info`. Override via CLI flags or `RUST_LOG`.
- Color control: `--color` flag, `LUNARIS_COLOR`, `NO_COLOR`, `CLICOLOR[_FORCE]`.
- Panics/exit: runtime prints errors via `tracing`; wrapper exits with code 1 when runtime fails.

## License

Dual-licensed under Apache 2.0 and MIT. See `LICENSE-APACHE` and `LICENSE-MIT`.

lunaris

lunaris 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

lunaris

lunaris 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README