musi lili

musi lili is a retro game engine for GB styled games written in Rust. Inspired by pico8.

Specifications

• Display: 160x144px 4 colors
• Sprites: 256 8x8 sprites
• Map: 128x64 tiles
• Framerate: ~60fps

Features

• Develop games with Rust
• built-in sprite editor
• built-in map editor
• 4 predefined colors palettes (gray, green, red, purple)
• Define your custom color palette
• Roadmap

Differences to pico8

• musi lili is a retro game engine not a complete Fantasy Console
• Games are build with Rust instead of Lua

Supported Platforms

• Desktop: works good on Linux, macOS and Windows.
• Web: musi lili games ca be compiled to WebAssembly and can be run in a web browser.
• Mobile: currently only Android is supported, iOS will be supported in the future.
• Embedded: no_std support is work in progress.

Controls

• Buttons
  • A: (A on keyboard)
  • B: (S on keyboard)
  • Select: (Space on keyboard)
  • Start: (Enter on keyboard)
  • Mouse: (Mouse left or right)
  • Left: (Left arrow key on keyboard)
  • Right: (Right arrow key on keyboard)
  • Up: (Up arrow key on keyboard)
  • Down: (Down arrow key on keyboard)
• Keys
  • CTRL-P: switch color palette
  • CTRL-R: restart game
  • CTRL-B: pause the game
  • Escape: switch between game and editor (debug build only)
  • CTRL-S: saves sprite-map and tile-map (debug build only)
  • CTRL-Z: undo on sprite editor and map editor (debug build only)
  • CTRL-Y: redo on sprite editor and map editor (debug build only)

Screenshots

Example Game	Sprite Editor	Map Editor

Web examples

Confetti	Drawing	Map

More examples in the examples folder.

Code Example

use musi_lili::{Game, Lili};

struct MyGame;

impl Game for MyGame {
    fn init(_lili: &Lili) -> Self {
        Self
    }

    fn update(&mut self, _lili: &Lili) {
        // the code to update your game
    }

    fn draw(&mut self, lili: &Lili) {
        // draw your game
        lili.clear(0);
        lili.txt("toki", 5, 5, 3);
    }
}

fn main() {
    musi_lili::run::<MyGame>(musi_lili::load!("my-game"));
}

Crates

• musi_lili: api library part, use this crate to implement you game.
• lon_lili: GB emulator frontend build with rgy.
• tan_lili: base components for input, drawing and api (internal).
• tawa_lili: runtime environment of lili (internal).

Implementation details

• games are drawn to a virtual display

• the editor uses the same features and api as a musi_lili::Game

Cargo Features

• std: use rust std (default).
• gamepad: activate gamepad support (needs libudev to be installed).
• slint-femtovg: use winit with femtovg renderer as slint backend (default).
• slint-software: use winit with software renderer as slint backend.
• experimental: enable this feature to try out experimental features that are not yet ready for production.

Used third party libraries

License

The source code of lili available under the terms of LGPL-3.0-only license. (See LICENSE-LGPL-3.0-only for details.). The source code of the examples if available under the terms of MIT license (See LICENSE-MIT for details.)

Contributions

If you are interested to contribute to the project, feel free to check the Contributing guide please.