Skip to content
jEngine

Installation

Prerequisites

Section titled “Prerequisites”

Before installing jEngine, you need:

Windows-Specific

Section titled “Windows-Specific”
  • Visual Studio Build Tools (C++ workload) — required for Rust compilation
  • CMake (optional, for some native dependencies)

Optional (for Web builds)

Section titled “Optional (for Web builds)”
  • wasm-pack — Install via cargo install wasm-pack
  • wasm32-unknown-unknown target — rustup target add wasm32-unknown-unknown

Clone the Repository

Section titled “Clone the Repository”
Terminal window
git clone https://github.com/user/jEngine.git
cd jEngine

Build the Engine

Section titled “Build the Engine”

Check all crates compile

Section titled “Check all crates compile”
Terminal window
cargo check --workspace

Run the native runtime (test scene)

Section titled “Run the native runtime (test scene)”
Terminal window
cargo run -p jengine-runtime

Build for Web (WASM)

Section titled “Build for Web (WASM)”
Terminal window
wasm-pack build crates/jengine-web --target web --release
# or a whole project, with its packages linked:
cargo run -p jengine-builder --bin jengine -- web-build projects/<name>

Build for Android

Section titled “Build for Android”
Terminal window
cargo run -p jengine-builder --bin jengine -- android-build projects/<name> --abi x86_64 --run

This makes a debug-signed APK without Gradle and starts it on a connected device or emulator. Android builds run Lua scripts only (no JavaScript).

Run clippy (lint)

Section titled “Run clippy (lint)”
Terminal window
cargo clippy --workspace -- -D warnings

Set Up the Editor

Section titled “Set Up the Editor”

The editor is a Tauri 2 + Svelte application. On Windows, install its tools once from the repo root:

Terminal window
.\setup-dev.ps1        # wasm-pack, tauri-cli and the wasm32 target (-DryRun to preview)

Then start it:

Terminal window
cd editor; npm install; cd ..
.
un-editor.ps1       # builds the viewport WASM (release), then runs `cargo tauri dev`

run-editor.ps1 rebuilds the editor’s viewport module each start so it matches the Rust code, and keeps it built for whichever project last needed its own packages. -DevWasm builds it unoptimised (faster to compile, not representative frame rates); -Clean fixes stale-library link errors.

From the editor you create scenes, add entities, attach scripts, and build your game.

Project Structure

Section titled “Project Structure”
jEngine/
├── crates/
│   ├── jengine-core/             # Engine library (renderer, ECS, scripting, physics, audio...)
│   ├── jengine-runtime/          # Native runtime (Windows, Android)
│   ├── jengine-web/              # WASM runtime for browsers
│   ├── jengine-editor-viewport/  # WASM module that runs the game inside the editor
│   ├── jengine-builder/          # Build pipeline and the `jengine` CLI
│   └── jengine-relay/            # Relay server for online play
├── packages/                     # Engine packages (Rust crates) - see /packages/
├── templates/                    # Scaffolds for `jengine package new`
├── editor/                       # Visual editor (Tauri 2 + Svelte)
├── projects/                     # Games and test projects built on the engine
├── docs/                         # Design notes and contracts
└── website/                      # This documentation site

Next Steps

Section titled “Next Steps”