update

riccardobl · riccardobl · commit ed0a51abb013 · 2025-06-09T21:44:42.000+02:00
diff --git a/docs/build.md b/docs/build.md
@@ -0,0 +1,134 @@
+
+**NGE** is a modern Java library, you can build and distribute your application in several ways, depending on your target platform and user base.
+
+!!! tip
+    The [template app](./getting-started.md) includes a **GitHub Actions** workflow that builds for all supported platforms using every available methods. 
+    You can use this as a reference or adapt it directly for your own project.
+
+
+
+## Building for Desktop
+
+### Portable JAR
+
+To build a standalone JAR file:
+
+
+```bash
+./gradlew build
+```
+
+or on Windows:
+
+```bash
+gradlew.bat build
+```
+
+The output will be located at:
+
+```
+dist/portable/yourapp-version-portable.jar
+```
+
+This is the traditional approach to distributing Java applications. It's simple, cross-platform, and requires only a single build step. 
+
+However, it has a few limitations:
+
+* Slightly longer startup time compared to native executables
+* Requires users to have **Java Runtime Environment (JRE) version 21 or higher** installed
+
+While you *can* manually bundle a JRE with your app, there's a better alternative, discussed next.
+
+
+### Installer
+
+This method packages the portable JAR **along with a JRE**, and wraps them in a platform-specific installer. It simplifies distribution and ensures your users don't need to install Java separately.
+
+
+```bash
+./gradlew buildInstaller
+```
+
+or on Windows:
+
+```bash
+gradlew.bat buildInstaller
+```
+
+The output will be located at:
+
+```
+dist/yourapp-version-platform.setup
+```
+
+!!! note
+     You can only create an installer for the platform you’re currently on. To support multiple platforms, you’ll need to run this process on each one individually.
+
+
+
+### Native Executable (Recommended)
+
+The most optimized way to distribute your app is as a **native executable**, which provides:
+
+* Significantly faster startup times
+* No need for users to install a JRE
+* No need to bundle a JRE with your app
+
+!!! note
+    Native builds require **GraalVM 24 or higher**. 
+    
+    You can install it easily using [SDKMAN](https://sdkman.io/):
+
+    ```bash
+    sdk install java 24-graal
+    ```
+
+
+Depending on the complexity of your app, you might need to run the *tracing agent* to help GraalVM understand your app's dependencies. 
+
+To do that you need to run  
+
+```bash
+./gradlew traceNative
+```
+
+and use all the features of your app. This will update the tracing files for GraalVM.
+
+When you are ready you can build the native executable with:
+
+
+```bash
+./gradlew buildNativeExecutable
+```
+
+or on Windows:
+
+```bash
+gradlew.bat buildNativeExecutable
+```
+
+The output will be located at:
+
+```
+dist/yourapp-version-platform.buildNative/
+```
+
+This directory includes the executable along with all required dependencies and resources that you will need to ship alongside with your app.
+
+
+!!! note
+    Native executables can **only** be built on the platform you're currently running. GraalVM does **not** support cross-compilation yet.
+
+
+
+## Building for Android
+
+TBD
+
+## Building for the Web (Browser)
+
+TBD
+
+
+## Building for iOS
+TBD
diff --git a/docs/components/index.md b/docs/components/index.md
@@ -28,7 +28,7 @@ public interface Component<T> {
 ## Fragments
 !!! abstract "See [Fragment Javadoc](https://javadoc.ngengine.org/org/ngengine/components/fragments/Fragment.html)"
 
-Fragments are interfaces that extend a component’s functionality. By implementing one or more fragment interfaces (e.g., `ViewPortFragment`, `LogicFragment`), a component signals which engine systems it needs. The manager detects these fragments and handles their lifecycle in a predefined order:
+Fragments are interfaces that extend a component’s functionality. By implementing one or more fragment interfaces (e.g., `MainViewPortFragment`, `LogicFragment`), a component signals which engine systems it needs. The manager detects these fragments and handles their lifecycle in a predefined order:
 
 1. **Initialization** (`receiveXXX` methods)  
 2. **Loading** (`loadXXX` methods)  
diff --git a/docs/getting-started.md b/docs/getting-started.md
@@ -1,4 +1,70 @@
-Getting started with NGE is straightforward. Everything begins with a `NGEApplication`, which you instantiate via a static method:
+Nostr Game Engine is fully modular: you can pick and choose individual engine components from our [GitHub Package Registry](https://github.com/orgs/NostrGameEngine/packages?repo_name=ngengine) and include them in any Gradle project. 
+
+However, the quickest way to start development is with the app template, detailed below.
+
+## Bootstrapping with the App Template
+
+Getting started with a new Nostr Game Engine project is easy thanks to the preconfigured Gradle template. 
+
+You can obtain the template in two ways:
+
+- **Clone the repository**:
+
+  ```bash
+  git clone https://github.com/NostrGameEngine/nge-app-template.git
+  ```
+
+- **Download as ZIP**:
+
+  [Download the Template App](https://github.com/NostrGameEngine/nge-app-template/archive/refs/heads/master.zip){ .md-button }
+
+After downloading, extract the contents to your workspace and open the project in your favorite Java IDE.
+
+!!! tip
+    We recommend using [Visual Studio Code](https://code.visualstudio.com/), but any Java-compatible IDE will work. 
+
+
+### Test the demo app
+
+Before going further, you can try to launch the demo app to ensure everything is set up correctly.
+
+Open a terminal in the project root and run:
+
+```
+./gradlew run
+```
+or on Windows:
+
+```powershell
+gradlew.bat run
+```
+
+![Demo App Screenshot](./images/demo-app.png)
+
+### Configure Project Properties
+
+Edit the `gradle.properties` file in the project root to customize your application details:
+
+```properties
+version=0.1
+projectName=ngeapp
+mainClass=org.example.NGEAppMain
+copyright=Copyright (c) 2025
+```
+
+you can also change `ngeVersion` if you want to use a different version of the engine.
+
+### Next Steps
+
+The next sections will walk you through the core concepts that make up a Nostr Game Engine application. 
+You can start experimenting with the source code you've just downloaded, to see how things work.
+
+Whenever your application is ready, you can head over to the [Building and Distribution](./build.md) section to learn how to package your app for distribution.
+
+
+## NGEApplication
+
+Everything begins with a `NGEApplication`, which you instantiate via a static method:
 
 ```java
 Runnable appBuilder = NGEApplication.createApp(app -> {
diff --git a/docs/images/demo-app.png b/docs/images/demo-app.png
diff --git a/docs/index.md b/docs/index.md
@@ -44,7 +44,7 @@ NGE follows many of the same paradigms as jMonkeyEngine 3 (jME3), so if you're a
 
 NGE modules use the following prefixes:
 
-- **jME3 Modules**: All original jMonkeyEngine 3 modules are re-published under the `jme-` prefix (for example, `jme-core`, `jme-graphics`, `jme-networking`).
+- **jME3 Modules**: All original jMonkeyEngine 3 modules are re-published under the `jme3-` prefix (for example, `jme3-core`, `jme3-lwjgl3`, `jme3-networking`).
 - **NGE Modules**: NGE-specific modules are published under the `nge-` prefix (for example, `nge-core`, `nge-auth`, `nge-network`).
 
 !!! Tip "You can mix and match `nge-` modules with any compatible jME3 release. However, for the latest bug fixes and cutting-edge features, we recommend using the latest NGE builds."
diff --git a/docs/postprocessing.md b/docs/postprocessing.md
@@ -1,19 +1,19 @@
 Postprocessing in NGE is anything that happens after the scene has been rendered but before it is displayed on the screen. This includes effects like bloom, depth of field,  and more.
 
-Postprocessing effects can be attached to a viewport with a component that implements [ViewPortFragment](https://javadoc.ngengine.org/org/ngengine/components/fragments/ViewPortFragment.html)  and overrides the `loadViewPortFilterPostprocessor` method, from there you can add your desired postprocessing effects to the [FilterPostProcessor](https://javadoc.ngengine.org/com/jme3/post/FilterPostProcessor.html) instance that is passed preconfigured to the method.
+Postprocessing effects can be attached to a viewport with a component that implements [MainViewPortFragment](https://javadoc.ngengine.org/org/ngengine/components/fragments/MainViewPortFragment.html)  and overrides the `loadMainViewPortFilterPostprocessor` method, from there you can add your desired postprocessing effects to the [FilterPostProcessor](https://javadoc.ngengine.org/com/jme3/post/FilterPostProcessor.html) instance that is passed preconfigured to the method.
 
 !!! example
     ```java
-    public class MyPostProcessingComponent implements Component<Object>, ViewPortFragment {
+    public class MyPostProcessingComponent implements Component<Object>, MainViewPortFragment {
         @Override
-        public void loadViewPortFilterPostprocessor(AssetManager assetManager, FilterPostProcessor fpp){
+        public void loadMainViewPortFilterPostprocessor(AssetManager assetManager, FilterPostProcessor fpp){
             // add your postprocessing effects here
             // fpp.addFilter(new BloomFilter());
             // ....
         }
 
         @Override
-        public void updateViewPort(ViewPort viewPort,float tpf) {}
+        public void updateMainViewPort(ViewPort viewPort,float tpf) {}
     }
     ```
 
diff --git a/mkdocs.yml b/mkdocs.yml
@@ -31,6 +31,7 @@ theme:
 nav:
   - Overview: index.md
   - Getting Started: getting-started.md
+  - Building and Distribution: build.md
   - Component System: components/index.md
   - Authentication: auth.md
   - Networking:
