Usagi Engine v1.0.0

Usagi Engine is a lightweight game development engine designed for creating 2D and 3D games with an emphasis on performance and developer control.

The engine is generally discussed within indie and experimental development circles rather than mainstream commercial game development ecosystems.

Usagi Engine prioritizes a modular architecture and streamlined workflow instead of massive integrated marketplaces or enterprise tooling systems.

Usagi Engine is an independent game engine project aimed at developers who prefer lightweight tooling, clean architecture, and direct control over the game development process. Unlike massive commercial engines that prioritize all in one ecosystems, Usagi Engine focuses more on flexibility, low level performance, and minimal overhead.

Although still relatively niche compared to major engines, it has attracted curiosity among indie developers and engine programming enthusiasts looking for alternatives to increasingly heavy mainstream game engines.

Key Features of Usagi Engine

  • Lightweight Architecture
    Usagi Engine focuses on keeping the engine relatively lean compared to larger commercial competitors, helping reduce unnecessary overhead.

  • 2D and 3D Rendering Support
    The engine supports both 2D and 3D game development workflows depending on the project configuration and rendering systems used.

  • Developer Oriented Design
    Usagi Engine appears targeted toward programmers and technical users who prefer direct engine level control instead of highly abstracted visual scripting systems.

  • Performance Focused Workflow
    The project emphasizes efficiency and responsiveness, which can appeal to developers working on optimized or experimental projects.

  • Modular Structure
    The engine architecture allows developers to adapt and extend systems rather than relying entirely on fixed workflows.

Download Usagi Engine v1.0.0 - Software Mirrors

Download Usagi Engine v1.0.0 for Windows
usagi-1.0.0-windows-x86_64.zip | 2.65 MB

Download Usagi Engine v1.0.0 for macOS
usagi-1.0.0-macos-aarch64.tar.gz | 2.89 MB

Download Usagi Engine v1.0.0 for Linux
usagi-1.0.0-linux-x86_64.tar.gz | 3.32 MB

Usagi Engine v1.0.0 Release Notes:

v1.0.0 of Usagi Engine is here! With it comes a promise of no breaking changes
until v2 (if that ever happens). :rabbit: :tada:
v1.0.0 comes with a lot of nice additions based on feedback from people making
their games. And some critical bug fixes and improvements.
Install Usagi v1.0.0:
  • Use usagi update if you already have it installed; then usagi refresh in your project(s)
  • Use the install script at https://usagiengine.com
  • Download for your operating system below

Breaking:

  • Pixel API renamed for consistency with the other shorthand primitives (rect,

circ, tri, spr, ...). The writer is now gfx.px(x, y, color), the
screen-pixel reader is gfx.get_px(x, y), and the sprite-pixel reader is
gfx.get_spr_px(index, x, y). The old names, gfx.pixel, gfx.px(x, y)
(two-arg reader), and gfx.spr_px, are gone. Find and replace in your code:
gfx.pixel → gfx.px, gfx.px(x, y) → gfx.get_px(x, y), gfx.spr_px →
gfx.get_spr_px. See #215
  • Palette slot 0 now resolves to true white (COLOR_TRUE_WHITE) instead of

the magenta out-of-range sentinel. Negative indices and indices past the
active palette's length still render as magenta, so the "obvious unknown
color" indicator survives for the common typo cases.
  • gfx.text_ex gained a required trailing alpha (0..1) param for parity

with gfx.spr_ex / gfx.sspr_ex. Pass 1.0 to keep the old behavior. The
simple gfx.text signature is unchanged.

Features:

  • New usagi.read_json(path) and usagi.read_text(path) for loading arbitrary

game data (level layouts, dialog scripts, tuning configs) from a project-level
data/ directory. Paths are forward-slash relative to data/, nested subdirs
supported (usagi.read_json("levels/01.json")). The whole data/ tree is
bundled by usagi export, so the same call resolves identically in dev and
shipped builds. Hot reload: any save to a data file pokes the same
script-reload path as a .lua save, so top-level
local levels = usagi.read_json("levels.json") picks up new bytes without F5.
New examples/level_from_json and examples/level_from_csv (the latter shows
the read_text + string.gmatch pattern for simple CSV grids, since the
engine doesn't ship a CSV parser).
See #218
  • New usagi.to_json(t) returns a Lua table as a pretty-printed JSON string.

Shares the shape validator with usagi.save, so keys must be all strings or a
dense 1..n integer array (functions, userdata, NaN, and cycles still error).
Useful for devtools, structured stdout logs, and any other place you want JSON
without writing to the save file. See examples/to_json.lua.
  • New gfx.tri(x1, y1, x2, y2, x3, y3, color) and

gfx.tri_fill(x1, y1, x2, y2, x3, y3, color) for drawing triangle outlines
and filled triangles from three points. Filled-triangle vertex order is
auto-corrected so arrows, spaceship nosecones, and pointer shapes draw
regardless of how you specified the points.
See #211
  • New gfx.COLOR_TRUE_WHITE constant: an off-palette pure (255, 255, 255)

white. Use it as the identity tint for gfx.spr_ex and gfx.sspr_ex when you
want sprite pixels to pass through unchanged. The Pico-8 gfx.COLOR_WHITE is
slightly warm (255, 241, 232) and tints sprites a touch peachy if used as
the identity, which is fine if you want a warm look but undesirable if you're
after pure pass-through. Available in every API that takes a palette index
(gfx.text, gfx.clear, gfx.rect, etc.) and stays pure white even with a
custom palette.png loaded.
  • New examples:
  • scene_switching: how to define multiple scenes like gameplay, main menu,

-- etc. and switch between them
  • The credit for the open source code that Usagi depends on is now included in

the engine's archive, detailing the various licenses. These are also viewable
at https://usagiengine.com/third-parties.
  • USAGI_VERBOSE=1 now emits a one-shot startup snapshot at boot (build

profile, platform, GC params, resolution, sprite size, pause-menu / palette /
font source, script path, Lua heap after _init) plus a per-second frame
summary line (avg / p50 / p99 / max frame time in ms, count of frames over the
16.7 ms budget, current Lua heap KB). The frame summary catches silent perf
regressions of the "still runs but slower" shape; the snapshot pins the env
for bug reports. Zero overhead when the env var is not set.
  • New examples/diagnostics to exercise both: short-lived table allocs in

_update with controls to scale the rate, plus a one-shot burst button to
provoke a GC cycle. Run as USAGI_VERBOSE=1 just example diagnostics and
watch the terminal.
  • Raylib's own boot chatter and per-frame TEXTURE log are now gated on a

separate USAGI_RAYLIB_VERBOSE=1, so the diagnostics stream stays readable.
Previously both shared USAGI_VERBOSE=1 and raylib's per-frame log buried the
frame summary. Set both env vars when you need everything.

Fixes:

  • GIF recordings now use 255 colors instead of the default Pico-8 color palette,

fixing an issue where exported GIF colors were wrong.
See #222
  • macOS no longer prints the GLFW "regular windows do not have icons on macOS"

warning at startup. Cocoa never honored the per-window icon anyway, so the
call was a known no-op; the .app bundle's AppIcon.icns is the path that
matters there, and it's still generated at usagi export --target macos time.
  • Passing a non-UTF-8 byte sequence (e.g. string.char(200)) to engine APIs

that take a string (gfx.text, gfx.text_ex, usagi.measure_text,
usagi.menu_item, sfx.play, music.play, gfx.shader_set, etc.) no longer
crashes on Windows. Bytes outside ASCII render as the U+FFFD replacement
character instead of erroring at the FFI boundary.
  • Error overlay text renders cleanly on Windows setups where the bundled font

was previously upscaled at a fractional ratio and came out blurred / curly.
The overlay now draws at an integer multiple of the bundled monogram's native
size. See #212
  • usagi.save now rejects unsupported table shapes with a clear message instead

of either a cryptic serde error or silent data loss. Tables with sparse
integer keys ({[6]=1, [7]=2}), gaps in a 1..n array ({[1]="x", [3]="z"}),
or mixed string/integer keys now error up front and point at the workaround.
JSON only supports maps with string keys or dense 1..n arrays.
See #220
  • Fixed slow shutdown after long sessions: switched Lua from generational to

incremental garbage collection, which keeps the heap bounded during play so
closing doesn't stall sweeping accumulated dead objects on exit.
See #232
  • Pause menu now always uses the engine's color palette (Pico-8) so that custom

color palettes don't inadvertently lead to illegible pause menu colors.

User Experience

Usagi Engine feels more like a technical developer platform than a beginner friendly drag and drop game creation tool.

Developers with programming experience will likely appreciate the cleaner architecture and reduced complexity compared to extremely large engines.

However, beginners may find the ecosystem difficult due to limited tutorials, smaller community support, and fewer ready made assets compared to engines like Unity or Unreal Engine.

The experience depends heavily on the developer’s comfort level with engine programming concepts.

Performance and Compatibility

Lightweight engines often perform well because they avoid many background systems and enterprise scale integrations found in larger engines.

Usagi Engine’s smaller footprint can make iteration faster and resource usage lower, especially for indie scale projects.

That said, niche engines frequently face limitations in tooling maturity, third party integrations, platform support, and documentation quality compared to industry dominant engines.

Community and Ecosystem

One challenge for Usagi Engine is ecosystem size.

Large engines benefit from enormous marketplaces, plugin libraries, tutorial ecosystems, and community troubleshooting resources. Smaller engines naturally struggle to compete in those areas.

Still, some developers specifically prefer smaller projects because they allow greater transparency, customization, and technical understanding of the engine internals.

Pros

  • Lightweight and performance focused

  • Cleaner architecture than many large engines

  • Flexible and modular design

  • Good for technical developers

  • Lower system overhead

Cons

  • Much smaller community ecosystem

  • Limited tutorials and learning resources

  • Less mature tooling compared to major engines

  • Not beginner friendly

  • Fewer plugins and ready made assets

Usagi Engine is best suited for experienced programmers, experimental developers, engine enthusiasts, and indie creators who prefer lightweight development environments with greater low level control.

Beginners or teams requiring large production ecosystems may be better served by more established engines.

Usagi Engine offers an interesting alternative approach to modern game development with its lightweight architecture and developer focused philosophy. While it lacks the ecosystem strength and maturity of mainstream engines, it remains an appealing option for technical users seeking simplicity, flexibility, and performance oriented workflows.

Usagi Engine v1.0.0
Free
Download

Software Informations:
Developer:

Operating System:
Windows / macOS / Linux
Date Added:
2026-05-23T16:32:18.242Z
Categories:

Post a Comment/Report Broken Link: