| 📰 Title: | jMonkeyEngine (jME) | 🕹️ / 🛠️ Type: | Tool |
|---|---|---|---|
| 🗃️ Genre: | Development | 👁️ Visual: | 2D & 3D |
| 🏷️ Category: | Development ➤ Engine ➤ 2D & 3D ➤ Misc. | 🏝️ Perspective: | Third & First person |
| 🔖 Tags: | Development; 2D & 3D engine; Framework; No UI; Java; jMonkeyEngine; LWJGL; Multi-platform; Code library; 3D Sound | ⏱️ Pacing: | Real Time |
| 🐣️ Approx. start: | 2011-03-13 | 👫️ Played: | Single & Multi |
| 🐓️ Latest: | 2024-09-18 | 🚦 Status: | 04. Released (status) |
| 📍️ Version: | Latest: 💥️ 3.7.0-stable // Dev: 5f54eb2 | ❤️ Like it: | 9. ⏳️ |
| 🏛️ License type: | 🕊️ Libre | 🎀️ Quality: | 7. ⏳️ |
| 🏛️ License: | BSD 3-Clause | ✨️ (temporary): | |
| 🐛️ Created: | 2011-10-05 | 🐜️ Updated: | 2024-11-05 |
| 📦️ Package name: | ..... 📦️ Arch: | ||
|---|---|---|---|
| 📄️ Source: |  |
..... 📦️ RPM: | |
| ⚙️ Generic binary: | |
..... 📦️ Deb: | |
| 🌍️ Browser version: | ..... 📦️ AppImage: | ||
| 📱️ PDA support: | |
..... 📦️ Flatpak: | |
| ✨️ Not use: | ..... 📦️ Snap: |
| 📰 What's new?: | 👻️ Temporary: | ||
|---|---|---|---|
| 💡 Lights on: | 🎨️ Significant improvement: | ||
| 👔️ Already shown: | 💭️ New version published (to be updated): | ||
| 🎖️ This work: |  |
🚧️ Some work remains to be done: | |
| 👫️ Contrib.: | goupildb & Louis | 🦺️ Work in progress: | |
| 🎰️ ID: | 11556 |
| 📜️[en]: | A libre, multi-platform Java framework/engine that makes it easy to design games in Java. This modular, minimalist and flexible tool is aimed at experienced Java programmers looking for performance. Its low level of abstraction enables precise control and high graphics performance. In particular, it offers several solutions for user interface development, support for numerous rendering types, post-processing with filters (Bloom, Volumetric Light, Tone Mapping, ...), particle management, physics (via the Bullet engine), network functionalities, 3D audio, terrain generation, and a libre code library for accelerated development. | 📜️[fr]: | Un framework / moteur Java libre et multi-plateforme facilitant la conception de jeux en Java. Cet outil modulaire, minimaliste et flexible se destine aux programmeurs expérimentés en Java qui recherchent la performance. Son faible niveau d'abstraction permet un contrôle précis et des performance graphiques élevées. Il offre notamment plusieurs solutions pour le développement d'interfaces utilisateur, le support de nombreux type de rendu, le post-traitement avec filtres (Bloom, Volumetric Light, Tone Mapping, ...), la gestion des particules, de la physique (via le moteur Bullet), des fonctionnalités réseau, l'audio 3D, la génération de terrains, et propose une bibliothèque de code libre permettant l'accélération des développements. |
|---|
🦝️ From Users: Gamefromscratch (201804), Gamefromscratch (201508),
🎮️ Showcase:
• Chaos, by 4Realms (201402), Skullstone, by Black Torch Games (202108), Spoxel (201903),
• Lightspeed Frontier, by Crowdwork Studios (201606), New Star Soccer, by New Star Games (201103), Wide up baseball game (200906),
🏡️ Website & videos
[Homepage] [Dev site] [Features/About 1 2] [Screenshots] [Videos t(202xxx) gd(202xxx) gu(201804) gu(201508) r(202xxx) lp(202xxx) sc(201510) sc(201103) d(201402) d(202108) d(201903) d(201606) d(201103) d(200906) d(201411) d(201603) d(202207) d(202305) d(202209) d(201312) d(201403) d(201406) d(201311) ht(201309) ht(201205) ht(201302) ht(201005) ht[fr](202xxx) ht[de](202xxx) ht[ru](201610) ht[pl](202xxx) ht[cz](202xxx) ht[sp](202xxx) ht[pt](202xxx) ht[it](202xxx) ht[tr](202xxx)] [WIKI 1 2 3] [FAQ] [RSS] [Changelog 1 2 3]
💰 Commercial
• [Support their work (Donate)]
🍩️ Resources
● Misc. tools:
• jMonkeyEngine3 SDK (It simplifies developing 3D Apps with the jMonkeyEngine (jME), containing everything ever needed to develop a full app): g(201005) [Homepage] [Dev site]
● GUI:
• Lemur(a jMonkeyEngine-based UI toolkit, BSD 3-Clause): g(202306) [Homepage] [Dev site]
• Nifty GUI (a Java library for building interactive GUIs for games or similar applications): g(201508) [Homepage] [Dev site]
• jme-IGUI (A minimalistic immediate GUI for jmonkeyengine, Public Domain): g(202010) [Homepage] [Dev site]
• jMonkeyBuilder (a 3D Editor to prepare/work/create graphics content for jMonkeyEngine 3.2): g(201801) [WIKI] [Dev site]
● Code Library:
• jMonkeyEngine Library (empty): [jMonkeyEngine Library]
🛠️ Technical informations
[Open Hub] [PCGamingWiki] [MobyGames] [Showcase]
🦣️ Social
Devs (jMonkeyEngine Team 1 2 [fr] [en]): [Site 1 2] [Chat] [mastodon] [PeerTube] [YouTube] [PressKit] [Interview 1(202xxx) 2(202xxx)]
The Project: [Blog] [Forums] [mastodon] [Facebook] [PeerTube] [YouTube] [PressKit] [reddit] [Discord]
🐝️ Related
[Wikipedia (jMonkey Engine) [fr] [en]] [de]]
[LibreGameWiki] [Mod DB] [Indie DB]
📦️ Misc. repositories
[Repology] [pkgs.org] [Generic binary] [Arch Linux / AUR] [openSUSE] [Debian/Ubuntu] [Flatpak] [AppImage(author's repo)] [Snap] [PortableLinuxGames]
🕵️ Reviews
[HowLongToBeat] [metacritic] [OpenCritic] [iGDB] [GameFromScratch]
🕊️ Source of this Entry: [Site (date)]
🦣️ Social Networking Update (on mastodon)
🛠️ Title: jMonkeyEngine
🦊️ What's: A libre 3D Java game engine / framework
🏡️ https://jmonkeyengine.org/
🐣️ https://github.com/jMonkeyEngine
🔖 #LinuxGameDev #LibreGameEngine #Java
📦️ #Libre #Bin
📖 Our entry: (homeless)
Dev ----------------------------------------
🥁️ Update: -
⚗️ -
📌️ Changes: https://github.com/jMonkeyEngine/jmonkeyengine/releases
🦣️ From: 🛜️ https://github.com/jMonkeyEngine/jmonkeyengine/releases.atom
Stable -------------------------------------
💥️ NEW!
🥁️ Update: 3.7.0
⚗️ Major release (Stable) 🍎️
📌️ Changes: https://github.com/jMonkeyEngine/jmonkeyengine/releases
🦣️ From: 🛜️ https://github.com/jMonkeyEngine/jmonkeyengine/releases.atom
🦝️ https://www.youtube.com/embed/nXLhBu4A3XY
🎮️ https://www.youtube.com/embed/gyfo_mFTVS8
🎮️ https://www.youtube.com/embed/ias1aZwsHRU
🎮️ https://www.youtube.com/embed/QeNjsTKRvls
🕶️ The engine logo
📚️ jMonkeyEngine is a libre, multi-platform Java framework/engine that makes it easy to design games in Java. This modular, minimalist and flexible tool is aimed at experienced Java programmers looking for performance. Its low level of abstraction enables precise control and high graphics performance. In particular, it offers several solutions for user interface development, support for numerous rendering types, post-processing with filters (Bloom, Volumetric Light, Tone Mapping, ...), particle management, physics (via the Bullet engine), network functionalities, 3D audio, terrain generation, and a libre code library for accelerated development.
📜️ "A libre 3D Java game engine / framework" 📜️
jMonkeyEngine is a modern developer friendly game engine written primarily in Java.
Its minimalistic and code first approach makes it perfect for developers who want the support of a game engine while retaining full control over their code with the ability to extend and adapt the engine to their workflow.
✅️ Powerful Graphics
jMonkeyEngine is only one level of abstraction away from OpenGL.
The engine exposes modern opengl capabilities and benefits from high performances due to its low level of abstraction.
Notable features include:
• Physically Based Rendering
• Singlepass Lighting
• Instanced Rendering
• Multitarget Rendering
• Tessellation
• Geometry Shaders
• Offscreen Rendering
• sRGB support with linearization
• Floating point textures
• Tone Mapping (HDR)
• Steep Parallax
• Shadows
And more...
✅️ Physics
jMonkeyEngine supports multiple physics solutions
• jBullet: java porting of Bullet Engine
• Minie : A binding to Bullet Engine, with support for rigidbody and softbody physics
✅️ Networking
There are multiple options to write netcode in jMonkeyEngine:
• Spidermonkey: A feature rich java client-server networking API that uses TCP and UDP packets. With support for RMI and Object Serialization.
• SimEthereal : A high performance library for real-time networked object synching
• Monkey Netty : A implementation of a server-client system using Netty.IO that utilizes both TCP and UDP.
✅️ GUI
In jMonkeyEngine there are several established choices for GUIs:
• Lemur : a modular library for 2D and 3D interactive guis, with a groovy-based styling language
• Nifty GUI: a library to build interactive user interfaces with support for xml layouts.
• IGUI : a minimalistic immediate GUI with minimal input handling
✅️ Postprocessing
jMonkeyEngine supports postprocessing out of the box and comes with several filters ready to use.
Such as:
• Bloom
• FXAA
• Cartoon Edges
• Light Scattering (GOD rays)
• SSAO
• Tone Mapping
• Volumetric Light
And more...
✅️ 3D Audio
jMonkeyEngine supports 3D audio with :
• OpenAL: Cross platform 3D audio. With basic support for positional sound and precomputed reverb.
• jmePhonon : Binding to SteamAudio for immersive sounds. With support for HRTF, occlusion, realtime reverberance and more... (pc only)
✅️ Terrain
There are several libraries and frameworks that aid in the creation of terrains in jMonkeyEngine.
Notable choices are:
• TerraMonkey: An high performance editable heightmap based terrain with autogenerated LOD and triplanar mapping.
• Blocks : A voxel engine with support for custom shapes, physics and endless terrain.
• IsoSurface : An isosurface terrain
• SimArboreal : A library to generate procedural trees
• SeaMonkey: Postprocessing filter that simulates water and underwater effects
✅️ Particles
jMonkeyEngine comes with particles capabilities in the core and multiple advanced thirdparty alternatives:
• jMonkey Particles: Simple and fast particles with support for point sprites and basic emitter logic
• Particle Monkey : A modern particle system with better artistic controls
• jme-EffekseerNative : Binding to the Effekseer particles runtime.
Multi Paradigm
✅️ Thanks to its flexibility, jMonkeyEngine can be used with different paradigms:
• Spatial-Control model: An intuitive model where Spatials are game entities and Controls determine their logic
• Zay-ES : High-performance entity-component-system model (ECS)
✅️ By The Community
During the years jMonkeyEngine has received many contributions in form of addons, assets and libraries.
Recently we launched the Software Store to collect all of them in a single place.
✅️ For The Developers
Simple, easy to setup, modular and minimalistic in its approach, jMonkeyEngine is made for the developers.
Its flexibility allows it to be adapted to different workflows and easily extended to support new features.
✅️ Free for everyone
jMonkeyEngine is free and opensource. Released under the permissive BSD 3-Clause license.
No splash screens, no fees and no requirement to mention jMonkeyEngine in your game at all.
✅️ And More...
(see above "[Features/About 2]")
🌍️ Wikipedia:
jMonkeyEngine (abbreviated JME) is an open-source and cross-platform game engine for developing 3D games written in Java. It uses shader technology extensively and can be used to write games for Windows, Linux, macOS, Raspberry Pi, Android, and iOS (currently in alpha testing). It uses Lightweight Java Game Library as its default renderer and another renderer based on Java OpenGL. it also supports OpenGL 2 to OpenGL 4.
jMonkeyEngine is a community-centric open-source software project released under the New BSD license. It is used by several commercial game studios and educational institutions. The default jMonkeyEngine 3 comes integrated with an advanced software development kit (SDK).
jMonkeyEngine 3 SDK
By itself, jMonkeyEngine is a collection of computing libraries, making it a low-level game development tool. Coupled with an integrated development environment like the official jMonkeyEngine 3 SDK, it becomes a higher-level game development environment with multiple graphical components.
The SDK is based on the NetBeans Platform, enabling graphical editors and plugin capabilities. Alongside the default NetBeans update centers, the SDK has its own plugin repository and a selection between stable point releases or nightly updates.
Since March 5th, 2016, the SDK is no longer officially supported by the core team. It is still being actively maintained by the community. The term "jMonkeyPlatform" is also used interchangeably with "jMonkeyEngine 3 SDK".
History
(...)
Un framework / moteur Java de jeu 3D libre, par la jMonkeyEngine Team.
Il utilise la bibliothèque LWJGL. En Java.
jMonkeyEngine (jME) est un framework / moteur Java libre et multi-plateforme facilitant la conception de jeux en Java. Cet outil modulaire, minimaliste et flexible se destine aux programmeurs expérimentés en Java qui recherchent la performance. Son faible niveau d'abstraction permet un contrôle précis et des performance graphiques élevées. Il offre notamment plusieurs solutions pour le développement d'interfaces utilisateur, le support de nombreux type de rendu, le post-traitement avec filtres (Bloom, Volumetric Light, Tone Mapping, ...), la gestion des particules, de la physique (via le moteur Bullet), des fonctionnalités réseau, l'audio 3D, la génération de terrains, et propose une bibliothèque de code libre permettant l'accélération des développements.
Utilisé par ces jeux / Used by these games: 3079, 3089, AgentKeeper, Attack of the Gelatinous Blob, Bang! Howdy, Chaos, Copod, Flesh Snatcher, Grappling Hook, Just Tactics, Mad Skills Motocross, Mythruna, Pirate Hell, Urban Galaxy,
Voir aussi / See also (jMonkeyEngine & fork): Ardor3D, jMonkeyEngine,
jMonkeyEngine est un moteur de jeu moderne et convivial écrit principalement en Java.
Son approche minimaliste et axée sur le code le rend parfait pour les développeurs qui souhaitent bénéficier du support d'un moteur de jeu tout en conservant un contrôle total sur leur code, avec la possibilité d'étendre et d'adapter le moteur à leur flux de travail.
✅️ Des graphismes puissants
jMonkeyEngine n'est qu'à un niveau d'abstraction d'OpenGL.
Le moteur expose les capacités modernes d'OpenGL et bénéficie de performances élevées grâce à son faible niveau d'abstraction.
Les caractéristiques notables sont les suivantes :
• Rendu basé sur la physique
• Éclairage à passage unique
• Rendu instancié
• Rendu multicible
• Tessellation
• Shaders de géométrie
• Rendu hors écran
• Support sRGB avec linéarisation
• Textures à points flottants
• Cartographie des tons (HDR)
• Parallaxe abrupte
• Ombres
Et plus encore...
✅️ Physique
jMonkeyEngine supporte plusieurs solutions physiques
• jBullet : portage java de Bullet Engine
• Minie : Une liaison au moteur Bullet, avec prise en charge de la physique des corps rigides et des corps mous.
Réseaux
Il existe plusieurs options pour écrire du netcode dans jMonkeyEngine :
• Spidermonkey : Une API de réseau client-serveur Java riche en fonctionnalités qui utilise les paquets TCP et UDP. Avec prise en charge de RMI et de la sérialisation d'objets.
• SimEthereal : une bibliothèque haute performance pour la synchronisation d'objets en réseau en temps réel.
• Monkey Netty : Une implémentation d'un système serveur-client utilisant Netty.IO qui utilise à la fois TCP et UDP.
INTERFACE GRAPHIQUE
Dans jMonkeyEngine, il existe plusieurs choix établis pour les interfaces graphiques :
• Lemur : une bibliothèque modulaire pour les interfaces graphiques interactives 2D et 3D, avec un langage de style basé sur groovy.
• Nifty GUI : une bibliothèque pour construire des interfaces utilisateur interactives avec un support pour les structures xml.
• IGUI : une interface graphique immédiate minimaliste avec une gestion minimale des entrées.
✅️ Post-traitement
jMonkeyEngine prend en charge le post-traitement dès le départ et est livré avec plusieurs filtres prêts à l'emploi.
Par exemple :
• Bloom
• FXAA
• Cartoon Edges (bords de dessins animés)
• Light Scattering (GOD rays) (diffusion de la lumière)
• SSAO
• Tone Mapping (cartographie des tons)
• Volumetric Light (lumière volumétrique)
Et plus encore...
✅️ Audio 3D
jMonkeyEngine prend en charge l'audio 3D avec :
• OpenAL : audio 3D multiplateforme. Avec un support de base pour le son positionnel et la réverbération précalculée.
• jmePhonon : Liaison avec SteamAudio pour les sons immersifs. Avec le support de HRTF, occlusion, réverbération en temps réel et plus encore... (pc seulement)
✅️ Terrain
Il existe plusieurs bibliothèques et frameworks qui aident à la création de terrains dans jMonkeyEngine.
Les choix notables sont :
• TerraMonkey : Un terrain éditable à haute performance basé sur une carte de hauteur avec des LOD autogénérés et une cartographie triplanaire.
• Blocks : Un moteur voxel avec un support pour les formes personnalisées, la physique et un terrain sans fin.
• IsoSurface : Un terrain isosurface.
• SimArboreal : Une bibliothèque pour générer des arbres procéduraux.
• SeaMonkey : Filtre de post-traitement qui simule l'eau et les effets sous-marins.
✅️ Particules
jMonkeyEngine est livré avec des capacités de particules dans le noyau et plusieurs alternatives tierces avancées :
• jMonkey Particles : Particules simples et rapides avec prise en charge des sprites ponctuels et logique d'émetteur de base
• Particle Monkey : Un système de particules moderne avec de meilleurs contrôles artistiques
• jme-EffekseerNative : Liaison avec le système de particules Effekseer.
Multi Paradigme
Grâce à sa flexibilité, jMonkeyEngine peut être utilisé avec différents paradigmes :
• Modèle de contrôle spatial : Un modèle intuitif où les Spatials sont des entités de jeu et des Controls déterminent leur logique.
• Zay-ES : Modèle entité-component-système (ECS) haute performance.
✅️ Par la communauté
Au cours des années, jMonkeyEngine a reçu de nombreuses contributions sous la forme d'addons, de ressources et de bibliothèques.
Récemment, nous avons lancé la boutique de logiciels pour les rassembler en un seul endroit.
✅️ Pour les développeurs
Simple, facile à configurer, modulaire et minimaliste dans son approche, jMonkeyEngine est fait pour les développeurs.
Sa flexibilité lui permet de s'adapter à différents flux de travail et d'être facilement étendu pour prendre en charge de nouvelles fonctionnalités.
✅️ Gratuit pour tous
jMonkeyEngine est gratuit et open source. Il est publié sous la licence permissive BSD 3-Clause.
Pas d'écran d'accueil, pas de frais et aucune obligation de mentionner jMonkeyEngine dans votre jeu.
✅️ Et plus encore...
(voir ci-dessus "[Features/About 2]")
🌍️ Wikipedia:
jMonkey Engine (jME) est un moteur de jeu libre spécialement conçu pour le développement 3D moderne comme il utilise extensivement la technologie de shader. jMonkey Engine est écrit en Java et utilise LWJGL pour son rendu par défaut (un autre système de rendu basé sur JOGL est disponible). OpenGL 2 à OpenGL 4 est pleinement supporté.
jMonkey Engine est un projet Open Source centré sur la communauté publié sous la nouvelle licence BSD. Il est utilisé par plusieurs studios de jeux vidéo et des institutions éducatives. C'est aussi un EDI, articulé autour de ce moteur de jeu, et basé sur l'EDI Netbeans : il inclut notamment son propre éditeur de terrain.
Il existe un fork de jMonkey nommé Ardor3D ayant notamment été utilisé lors de la mission Mars Curiosity par la NASA.