| 📰 Title: | Libretro | 🕹️ / 🛠️ Type: | Tool |
|---|---|---|---|
| 🗃️ Genre: | Emulation | 👁️ Visual: | Text |
| 🏷️ Category: | Emulation ➤ Engine ➤ Multi | 🏝️ Perspective: | Third person |
| 🔖 Tags: | Game Launcher; Framework; Emulation; Multi Emulation; libretro compatible | ⏱️ Pacing: | Real Time |
| 🐣️ Approx. start: | 2005-04-17 | 👫️ Played: | Single & Multi |
| 🐓️ Latest: | 2021-05-30 | 🚦 Status: | 04. Released (status) |
| 📍️ Version: | Latest: - / Dev: 3ad323 | ❤️ Like it: | 9. ⏳️ |
| 🏛️ License type: | 🕊️ Libre | 🎀️ Quality: | 7. ⏳️ |
| 🏛️ License: | GPL-3 | ✨️ (temporary): | |
| 🐛️ Created: | 2021-06-27 | 🐜️ Updated: | 2024-10-10 |
| 📦️ Package name: | libretro-* | ..... 📦️ 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: | 16064 |
| 📜️[en]: | Libretro is an application / abstraction layer, allowing to manage emulators, games or other applications in the form of plugins (taking the name of "libretro cores" or "game cores"), and thus to make them cross-platform, by supporting the link between this application (example: an emulator), the user's hardware and a specific interface ("frontend" in English) such as RetroArch, Ludo or RetroGTK, allowing the setup of the libretro cores. | 📜️[fr]: | Libretro est une application / une couche d'abstraction, permettant de gérer des émulateurs, des jeux ou d'autres applications sous forme de plugins (prenant le nom de "libretro cores" ou "game cores"), et ainsi de les rendre multi-plateforme, en prenant en charge le lien entre cette application (exemple : un émulateur), le matériel de l'utilisateur et une interface spécifique ("frontend" en anglais) telle que RetroArch, Ludo ou RetroGTK, permettant le paramétrage de l'ensemble. |
|---|
🏡️ Website & videos
[Homepage] [Dev site] [Features/About] [Screenshots] [Videos t(202xxx) gd(202xxx) gu(202xxx) r(202xxx) lp(202xxx) ht(202xxx) g(202xxx) g[fr](202xxx) g[de](202xxx) g[ru](202xxx) g[pl](202xxx) g[cz](202xxx) g[sp](202xxx) g[pt](202xxx) g[it](202xxx) g[tr](202xxx)] [WIKI] [FAQ] [RSS:no] [Changelog 1 2 3]
💰 Commercial
• [Patreon] [Liberapay] [Bountysource]
🍩️ Resources
• Lakka (a lightweight Linux distribution that transforms a small computer into a full blown game console): [Homepage] [Dev site]
🛠️ Technical informations
[PCGamingWiki] [MobyGames] [EMU GEN] [Libretro (What is libretro?)]
🦣️ Social
Devs (The Libretro Team 1 2 [fr] [en]): [Site 1 2] [Patreon] [Liberapay] [Bountysource] [Forums] [mastodon] [PeerTube] [YouTube] [PressKit] [Interview 1(202xxx) 2(202xxx)]
The Project: [Blog] [Forums] [mastodon] [PeerTube] [YouTube] [Instagram] [PressKit] [reddit] [Discord]
🐝️ Related
[Wikipedia (Libretro) [fr] [en] [de]]
[HOLaRSE [de]]
📦️ 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]
🕊️ Source of this Entry: [Site (date)]
🦣️ Social Networking Update (on mastodon)
🛠️ Title: Libretro
🦊️ What's: An application for managing emulators, games & other applications
🏡️ https://www.libretro.com
🐣️ https://github.com/libretro
🔖 #LinuxEmulation #Framework #Plugins
📦️ #Libre #Arch #RPM #Deb
📖 Our entry: (homeless)
🥁️ Update:
⚗️
📌️ Changes:
🦣️ From: 🛜️
🏝️ https://www.youtube.com/embed/
🦉️ https://www.youtube.com/embed/
🦝️ https://www.youtube.com/embed/
🦝️ https://www.youtube.com/embed/
🕵️ https://www.youtube.com/embed/
🕯️https://www.youtube.com/embed/
🕯️https://www.youtube.com/embed/
🎲️ https://www.youtube.com/embed/
🎲️ https://www.youtube.com/embed/
🎲️ https://www.youtube.com/embed/
🎲️[fr] https://www.youtube.com/embed/
🎮️ https://www.youtube.com/embed/
🎮️ https://www.youtube.com/embed/
🐧https://www.youtube.com/embed/
🐧https://www.youtube.com/embed/
🕶️
📚️ Libretro is an application / abstraction layer, allowing to manage emulators, games or other applications in the form of plugins (taking the name of "libretro cores" or "game cores"), and thus to make them cross-platform, by supporting the link between this application (example: an emulator), the user's hardware and a specific interface ("frontend" in English) such as RetroArch, Ludo or RetroGTK, allowing the setup of the libretro cores.
📜️ "An application for managing emulators, games & other applications" 📜️
Libretro is a simple but powerful development interface that allows for the easy creation of emulators, games and multimedia applications that can plug straight into any libretro-compatible frontend. This development interface is open to others so that they can run these pluggable emulator and game cores also in their own programs or devices.
With libretro, you can make multi-platform applications that can use rich features such as OpenGL, multi-platform camera support, location support, and more in the future.
Libretro is an API that exposes generic audio/video/input callbacks. A frontend for libretro (such as RetroArch) handles video output, audio output, input and application lifecycle. A libretro core written in portable C or C++ can run seamlessly on many platforms with very little/no porting effort.
While RetroArch is the reference frontend for libretro, several other projects have used the libretro interface to include support for emulators and/or game engines. libretro is completely open and free for anyone to use.
➤ What is libretro?
Download the RetroArch/Libretro Technical Brochure (PDF) (see "What is libretro?" link above)
Libretro is a simple API that allows for the creation of games and emulators. It is very simple in nature, yet very powerful. The simplicity of it all requires some explanation in order to truly grasp how useful it can be to your own projects.
When you choose to use the libretro API, your program gets turned into a single library file (called a ‘libretro core’). A frontend that supports the libretro API can then load that library file and run the app. The frontend’s responsibility is to provide all the implementation-specific details, such as video/audio/input drivers. The libretro core’s responsibility is solely to provide the main program. You therefore don’t have to worry about writing different video drivers for Direct3D, OpenGL or worrying about catering to all possible input APIs/sound APIs/supporting all known joypads/etc. This is none of your concern at the libretro core implementation level.
Any project that is ported to work with this API can be made to run on ANY libretro frontend – now and forever. You maintain a single codebase that only deals with the main program, and you then target one single API (libretro) in order to port your program over to multiple platforms at once.
Other projects benefit from our ever-expanding libretro core software library by implementing the libretro API inside their own projects. To this end, project such as XBMC have already begun writing a libretro driver based on the RetroArch reference libretro frontend.
RetroArch is the official reference frontend, and it is available on nearly all modern-day platforms. It is meant to be fast, simple, yet powerful.
Other platform-specific frontends are currently in development, including native integration with the popular HTPC platform XBMC.
➤ Who Uses Libretro?
While the most common use case for libretro has been console emulation, it is equally suited as a platform for almost any 2D game. For example, the NX Engine used in the popular freeware game Cave Story has been successfully ported to libretro, open sourced games like Quake and Doom have been ported to libretro, and the new freeware game Dinothawr supports libretro natively.
➤ Libretro GL/Vulkan
Aside from retro-style games and emulators that depend on software rendering and where you’d typically need nothing more than the ability to render to a framebuffer, the Libretro API also allows you to target OpenGL and Vulkan. This allows you to create libretro ports that use OpenGL or Vulkanas part of their internal rendering.
From a portability perspective, we highly recommend that you try to target both so that your libretro GL port will work on both mobile and desktop computers.
➤ Why Should Developers Target Libretro?
Software that targets the libretro API instantly gains access to all of the platforms that have libretro frontends available. That means your game is immediately available to those platforms’ users without worrying about input/audio/video drivers, compatibility issues or the myriad quirks of the underlying host system(s). Likewise, there’s no need to write specialized GUI code for each platform or to use esoteric–and often buggy–multi-platform toolkits, like Qt and GTK+.
Furthermore, once your game supports libretro, all of the libretro frontends’ other features come along for free, such as RetroArch’s real-time rewind, lag-concealing netplay, lossless video recording/streaming and cutting-edge post-processing shader support.
Perhaps best of all: libretro is an open specification that is 100% free to implement, with no licensing fees or hidden strings attached.
If you’d like to learn more about libretro, leave us a comment or chat with us on IRC at #retroarch on Freenode.
Libretro’s design goals
Libretro is the library programming interface. Programs get ported to this library and can then be run with any libretro-compatible frontend.
Our reference frontend is RetroArch. The two projects are not the same, and this is reflected in the licensing as well. RetroArch sticks to GPL-ersion 3 whereas the libretro API is a MIT-licensed API.
Some of the design goals for libretro:
• Allow a non-kitchensink approach to crossplatform portability.
• Allow a non-dependency heavy approach to crossplatform portability. Stick to just one header containing definitions for the necessary audio/video/input callbacks.
• Care about being backwards compatible. Libretro’s ABI( Application Binary Interface) has never been broken in years, and old libretro frontends from years ago in most cases can still use libretro cores being created today.
• By its very design enables programs to be ported to singular dynamic libraries which can then be loaded in and out of frontend applications thanks to the libretro API.
• Forces you by its design to rethink what code belongs to ‘core land’ and what should belong to ‘frontend land’. Libretro cores ideally should have minimal to no dependencies on any system/OS-specific APIs so that the same libretro cores can work on any libretro-compatible frontend.
• Designed with games, emulators and multimedia in mind. Libretro core ports resemble ports being done to standalone game consoles or mobile where the primary input device is not a keyboard and mouse (although libretro supports those as well).
• Does not concern itself with external WIMP GUIs (since they are not portable), or anything that would tie itself to mainly desktop PC-usage. Libretro cores ideally have to work seamlessly on mobile, desktop PC and game consoles.
• Requires you to link your libretro-ported program to a libretro frontend, leaves the libretro frontend creation part up to you or lets you select one of the mature libretro frontends already available.
Une couche d'abstraction pour émulateurs, jeux et applications 3D, prenant en charge l'interface et le matériel, et les rendant multi-plateforme, par The Libretro Team.
Libretro est une application / une couche d'abstraction, permettant de gérer des émulateurs, des jeux ou d'autres applications sous forme de plugins (prenant le nom de "libretro cores" ou "game cores"), et ainsi de les rendre multi-plateforme, en prenant en charge le lien entre cette application (exemple : un émulateur), le matériel de l'utilisateur et une interface spécifique ("frontend" en anglais) telle que RetroArch, Ludo ou RetroGTK, permettant le paramétrage de l'ensemble.
Voir aussi / See also (libretro & GUI): Libretro, Ludo, RetroArch, RetroGTK,
Libretro est une interface de développement simple mais puissante qui permet de créer facilement des émulateurs, des jeux et des applications multimédias qui peuvent se connecter directement à n'importe quel frontend (NdT : aka IHM aka une interface utilisateur, tel que RetroArch ci-après) compatible. Cette interface de développement est ouverte aux autres afin qu'elles puissent exécuter ces émulateurs pluggables et game cores (NdT : cœurs de jeux, aka le programme de base faisant tourner le jeu) également dans leurs propres programmes ou périphériques.
Avec libretro, vous pouvez créer des applications multi-plateformes qui peuvent utiliser des fonctionnalités riches telles qu'OpenGL, le support de caméras multi-plateforme, le support de localisation et plus à l'avenir.
Libretro est une API qui expose des appels génériques audio / vidéo / entrée. Un frontend pour libretro (tel que RetroArch) gère la sortie vidéo, la sortie audio, l'entrée et le cycle de vie de l'application. Un libretro core écrit en portable C ou C ++ peut fonctionner de manière transparente sur de nombreuses plateformes avec très peu / aucun effort de portage.
Alors que RetroArch est le frontend de référence pour libretro, plusieurs autres projets ont utilisé l'interface libretro pour inclure un support pour des émulateurs et / ou des moteurs de jeux. Libretro est complètement ouvert et libre pour tout le monde.
➤ Qu'est ce que libretro?
Téléchargez la Brochure technique RetroArch / Libretro (PDF) (voir le lien "What is libretro?" Ci-dessus)
Libretro est une API simple qui permet la création de jeux et d'émulateurs. C'est très simple, mais très puissant. La simplicité de tout cela nécessite des explications afin de mieux comprendre à quel point il peut être utile pour vos propres projets.
Lorsque vous choisissez d'utiliser l'API libretro, votre programme est transformé en un seul fichier de bibliothèque (appelé «libretro core»). Un frontend qui prend en charge l'API libretro peut alors charger ce fichier de bibliothèque et exécuter l'application. La responsabilité de l'interface est de fournir tous les détails spécifiques d'implémentation, tels que les pilotes vidéo / audio / d'entrée. La responsabilité du libretro core est uniquement de fournir le programme principal. Vous n'avez donc pas à vous soucier d'écrire différents pilotes vidéo pour Direct3D, OpenGL ou de vous soucier de fournir toutes les API / API sonores / le support de tous les joypads connus / etc. Ceci n'est pas votre préoccupation pour le niveau d'implémentation de libretro core.
Tout projet utilisé pour fonctionner avec cette API peut être conçu pour être exécuté sur n'importe quel frontend de libretro - dès à présent et pour toujours. Vous maintenez une base de code unique qui ne traite que du programme principal, puis vous ciblez une seule API (libretro) afin de transférer votre programme sur plusieurs plateformes à la fois.
D'autres projets bénéficient de notre bibliothèque de logiciels libretro core en constante expansion en mettant en œuvre l'API libretro dans leurs propres projets. À cette fin, un projet tel que XBMC a déjà commencé à écrire un driver libretro basé sur le frontend de référence RetroArch.
RetroArch est le frontend officiel de référence, et il est disponible sur presque toutes les plateformes modernes. Il est destiné à être rapide, simple et puissant.
D'autres frontends spécifiques à des plateformes sont actuellement en développement, y compris l'intégration native avec la populaire plateforme HTPC XBMC.
➤ Qui utilise Libretro ?
(...)
➤ Libretro GL/Vulkan
(...)
➤ Pourquoi les développeurs devraient-ils se tourner vers Libretro?
(...)