Libretro (+ RetroArch | Ludo) - Le Bottin des Jeux Linux

Libretro (+ RetroArch | Ludo)

Specifications

Title: Libretro (+ RetroArch | Ludo) Type: Tool
Genre: Emulation Status:
Category: Emulator ➤ GUI ➤ Multi Commercial:
Tags: Game Launcher; GUI; Emulator; Multi Emulator; id Tech 4 engine; Doom; Multi-platform; libretro compatible Demo:
Released: Libretro (Latest : - / Dev : 4927669) ♦ RetroArch (Latest : 1.9.0 / Dev : 8f60e63) ♦ Ludo (Latest : 0.11.2 / Dev : 2872940) Package Name: retroarch
Date: 2020-09-10 Extern Repo: Flatpak
License: GPL v3 Repo: Debian
Perspective: Third person Package: ✓
Visual: 2D Binary: ✓
Pacing: Real Time Source: ✓
Played: Single & Multi PDA: ✓
Quality (record): 5 stars Quality (game):
Contrib.: Goupil & Louis ID: 15256
Created: 2017-06-20 Updated: 2020-09-15

Summary

[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 ou Ludo, permettant le paramétrage de l'ensemble. [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 or Ludo, allowing the setup of the libretro cores.

Videos

RetroArch:

How To utilisateur / User How To :


Fonctionnalités / Features :
• Quick: Save States, Doom 3 Libretro core dhewm3, AI Service Allows For Machine Translation from Japanese to English!,

• Direct3D11 driver, 4K resolution at 60fps : (VitaQuake),


Gameplay (SP) :


Gameplay (MP) :


-------------------------------------------- § ---------------------------------------------


Ludo:

Présentation des développeurs / Dev presents :

Links

Website & videos
• Libretro: [Homepage] [Dev site] [Features/About] [WIKI] [FAQ] [RSS:no] [Changelog 1 2(not used) 3]
• RetroArch: [Homepage] [Dev site] [Features/About] [Screenshots] [Videos ft ft ft ft ft t ts mp d d d d d d d d d id r lp ht ht ht g[fr] g[de] g[ru] g[pl] g[cz] g[sp] g[pt] g[it] g[tr] g] [WIKI] [FAQ] [RSS] [Changelog 1 2 3]
• Ludo: [Homepage] [Dev site] [Features/About] [Screenshots] [Videos t ts gd gu id r lp g g[fr] g[de] g[ru] g[pl] g[cz] g[sp] g[pt] g[it] g[tr] g g] [WIKI] [FAQ] [RSS] [Changelog 1 2 3]

Commercial : [Support their work (Donate)] [Patreon] [Liberapay] [Bountysource] [Steam (Steam Launch Update)]

Resources
• Lakka (a lightweight Linux distribution that transforms a small computer into a full blown game console) : [Homepage] [Dev site]
Technical informations
[Open Hub] [PCGamingWiki] [MobyGames] [Libretro (What is libretro?)][RetroArch (Getting Started)] [FantasyAnime (RetroArch Tutorial)]

Social
Devs (The Libretro Team 1 2 [fr] [en]) : [Site 1 2] [Patreon] [Liberapay] [Bountysource] [Forums] [twitter] [YouTube] [Interview 1 2]
Game : [Blog] [Forums] [twitter] [YouTube] [Instagram] [Discord]

On other sites
[Wikipedia (Libretro) [fr] [en] [de]]
[Wikipedia (RetroArch) [fr] [en] [de]]
[Debian] [HOLaRSE [de]] [EMU GEN]

Reviews
[metacritic]

News / Source of this Entry (SotE) / News (SotN)
• RetroArch: [Changes with v. 1.9.0 (20200809)] [Gaming on Linux on Mastodon (20200810) (SotN)] [HOLaRSE on Mastodon [de] (20200815)]
• Ludo: [Changes with v. 0.11.2 (20200717)] [Gaming on Linux on Mastodon (20200831) (SotE)]

Description [fr]

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 ou Ludo, permettant le paramétrage de l'ensemble.

Utilisé par ces jeux & émulateurs / Used by these games & emulators : DeSmuME, Dolphin, DOSBox, Fuse, Gambatte, Genesis Plus GX, Hatari, melonDS, mGBA, Mupen64Plus, Nestopia, NXEngine (Cave Story game engine), OpenLara, pSX, Redream, SameBoy, ScummVM, Snes9x, Stella, Vice, Virtual Jaguar,


Libretro:

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 plates-formes 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?

(...)


RetroArch :

RetroArch est une interface pour les émulateurs, les moteurs de jeu et les lecteurs multimédias.

Il vous permet d’exécuter des jeux classiques sur un large éventail d’ordinateurs et de consoles grâce à son interface graphique élégante. Les paramètres étant également unifiés, la configuration est effectuée une fois pour toutes.

De plus, vous pourrez bientôt utiliser les disques de jeu originaux (CD) de RetroArch.

RetroArch propose des fonctionnalités avancées telles que shaders, netplay, rembobinage, temps de réponse de la prochaine image, avance rapide et plus encore !


RetroArch est l'interface de référence de l'API libretro. Des exemples populaires d'implémentations pour cette API incluent des émulateurs de systèmes de jeux vidéo et des moteurs de jeux, mais aussi des programmes 3D plus généralistes. Ces programmes sont instanciés en tant que bibliothèques dynamiques. Nous les appelons des "libretro cores" (NdT : des cœurs libretro).

Glossaire

• Core - un core (NdT : cœur) est un programme qui s'exécute dans RetroArch (ou un autre frontend pour libretro)
• Frontend - un frontend dans ce contexte est un programme qui peut exécuter des cœurs libretro (RetroArch, Minir, Retroplayer de Kodi en sont des exemples)
• Content - le content (NdT : contenu) est un jeu / programme géré par un cœur, certains cœurs ne nécessitent pas non plus de contenu
• Retropad - retropad est le contrôleur d'abstraction d'entrée de RetroArch, c'est l'interface entre le contrôleur physique et les entrées du cœur
• Save Files (NdT : fichiers sauvegardés) - les fichiers sauvegardés sont sauvegardés à partir d'un jeu, généralement multi-plateforme, et devraient fonctionner au travers des émulateurs dans la plupart des cas
• Save States (NdT : Enregistrer les États) - les états d'enregistrement sont des instantanés (snapshots) du contenu de la mémoire à un moment donné, ceux-ci ne sont pas toujours multi-plateforme et ne fonctionneront certainement pas sur un émulateur autre que celui utilisé pour les créer
• System Files (NdT : Fichiers système) - des fichiers supplémentaires qui pourraient ou non faire partie du romset qui pourraient être nécessaires pour que le contenu soit utilisé (généralement mentionné sous le terme BIOS)
• Autoconf Profile - un fichier de configuration qui a des définitions de bouton pour un gamepad particulier



Ludo:

Ludo est une interface minimaliste pour les émulateurs.

Ludo est une interface pour émulateur capable de gérer des jeux vidéo rétro. Ludo n'émule pas les consoles elles-mêmes, mais le fait par le biais de plugins d'émulation appelés "libretro cores". Les librestro cores sont des émulateurs bien connus (comme Snes9x ou Genesis Plus GX ou PCSX) dépouillés de leur interface utilisateur. Ils ne contiennent que la logique spécifique à la console.

Séparer le frontend de la logique d'émulation présente les avantages suivants :

• Les développeurs du frontend n'ont à coder l'interface utilisateur qu'une seule fois
• Le développement d'une nouvelle fonctionnalité frontale peut profiter à tous les émulateurs à la fois
• Les développeurs d'émulateurs peuvent bénéficier d'une interface utilisateur mature sans avoir à la coder
• Les joueurs peuvent configurer les émulateurs d'un seul coup
• L'interface utilisateur, la configuration et le stockage sont cohérents d'un émulateur à l'autre

Du point de vue du joueur, Ludo est un navigateur et un lecteur de jeu rétro universel. Il offre une expérience de jeu optimisée pour la télévision et les joypads, mais peut également être utilisé sur un PC traditionnel avec un clavier.

Objectifs

Stabilité, Intuitivité, Facilité d'utilisation, Minimalisme, Portabilité modérée, Précision

Non objectifs

Exhaustivité des fonctionnalités, Hautes performances, Portabilité extrême, Personnalisation

Plates-formes supportées

(...)


Debian (traduction du Bottin) :

Un frontend simple pour la bibliothèque libretro

RetroArch est un frontend / interface open source, multi-plateforme pour l'API libretro. Il peut être utilisé comme système multi-émulateur modulaire, un moteur de jeu, un lecteur multimédia ou une démonstration technique 3D. Ces fonctionnalités sont disponibles via les libretro cores.

Description [en]

"An application (& its frontends) for managing emulators, games and other applications" -- Le Bottin

Libretro:

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 version 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.


RetroArch:

RetroArch is a frontend for emulators, game engines and media players.

It enables you to run classic games on a wide range of computers and consoles through its slick graphical interface. Settings are also unified so configuration is done once and for all.

In addition to this, you will soon be able to run original game discs (CDs) from RetroArch.

RetroArch has advanced features like shaders, netplay, rewinding, next-frame response times, runahead, and more!


RetroArch is the reference frontend for the libretro API. Popular examples of implementations for this API includes videogame system emulators and game engines, but also more generalized 3D programs. These programs are instantiated as dynamic libraries. We refer to these as "libretro cores".

Terms

• Core — a core is a program that runs in RetroArch (or another libretro frontend)
• Frontend — a frontend in this context is a program that can run libretro cores (RetroArch, Minir, Kodi’s Retroplayer are examples of this)
• Content — content is a game/program that is run by a core, some cores also require no content
• Retropad — retropad is RetroArch’s input abstraction controller, it’s the interface between the physical controller and the core inputs
• Save Files — save files are saves that are made from within a game, usually cross platform and should work across emulators in most cases
• Save States — save states are snapshots of the content menory at a particular moment, these are not always cross platform and most certainly won’t work on a different emulator that the one used to create them
• System Files — additional files that might or not be part of the romset that might be needed to get some content to work (usually referred to by the BIOS term)
• Autoconf Profile — a configuration file that has button definitions for a particular gamepad


Debian :

Simple frontend for the libretro library

RetroArch is an open source, multi-platform frontend for the libretro API. It can be used as a modular multi emulator system, game engine, media player and 3D technical demonstration. These features are available through libretro cores.


Ludo:

Ludo is a minimalist frontend for emulators

Ludo is an Emulator Frontend able to run retro video games. Ludo does not emulate the consoles itself, but does it through emulator plugins called libretro cores. Libretro cores are well known emulators (like Snes9x or Genesis Plus GX or PCSX) stripped from their user interface. They contain only console specific logic.

Separating the frontend from the emulation logic has the following advantages:

• Frontend developers only have to code the user interface once
• Developing a new frontend functionality can benefit all the emulators at once
• Emulator developers can benefit from a mature user interface without coding it
• Gamers can configure emulators all at once
• The user interface, configuration, and storage are consistent across emulators

From the gamer perspective, Ludo is a universal retro game browser and player. It offers a gaming experience optimized for TV and joypads, but can also be used on a traditional PC with a keyboard.

Goals

Stability, Intuitiveness, Ease of use, Minimalism, Moderate portability, Correctness

Non goals

Feature completeness, High performance, Extreme portability, Custom

Supported platforms

(...)