Files

T

2026-05-16 23:59:22 +02:00

22 KiB

Raw Blame History

FreeDOS

FreeDOS est un système d'exploitation libre et open source compatible avec MS-DOS. Il permet d'exécuter de vieux programmes et jeux des années 80-90 sur du matériel moderne ou dans une machine virtuelle. Distribué sous licence GPL, il est entièrement gratuit et activement maintenu par sa communauté.

Cas d'usage typiques :

Faire tourner d'anciens jeux DOS (Doom, Commander Keen, etc.)
Exécuter des logiciels professionnels legacy (comptabilité, CAO ancienne)
Flasher un BIOS depuis un environnement DOS
Apprendre l'histoire de l'informatique

Installer FreeDOS dans une machine virtuelle sous Linux

L'approche en VM est de loin la plus pratique : pas de risque pour ton système, snapshots possibles, et configuration matérielle reproductible. Voici la méthode avec QEMU/KVM (natif Linux, léger) et VirtualBox (plus visuel).

Prérequis communs

Télécharge l'image ISO sur le site officiel : https://www.freedos.org/download/ (choisis le LiveCD ou FullUSB au format .iso).

Méthode 1 — QEMU (recommandée sous Linux)

Installation des paquets selon ta distribution :

# Debian / Ubuntu
sudo apt install qemu-system-x86 qemu-utils

# Fedora
sudo dnf install qemu-system-x86 qemu-img

# Arch
sudo pacman -S qemu-full

Crée un disque dur virtuel de 2 Go (largement suffisant pour DOS) :

qemu-img create -f qcow2 freedos.qcow2 2G

Démarre l'installation depuis l'ISO :

qemu-system-i386 \
  -m 64 \
  -hda freedos.qcow2 \
  -cdrom FD13LIVE.iso \
  -boot d

Une fois FreeDOS installé sur le disque virtuel, démarre directement dessus :

qemu-system-i386 -m 64 -hda freedos.qcow2 -boot c

64 Mo de RAM (-m 64) suffisent largement — DOS n'utilise nativement que 640 Ko de mémoire conventionnelle.

Méthode 2 — VirtualBox

sudo apt install virtualbox    # Debian/Ubuntu

Nouvelle machine → Type : Other, Version : DOS
RAM : 64 Mo, Disque dur : 2 Go (VDI, dynamiquement alloué)
Dans les paramètres de la VM → Stockage → ajoute l'ISO de FreeDOS au lecteur optique
Démarre la VM et suis l'installateur de FreeDOS

Monter des images de disquettes

Très utile pour faire tourner des vieux logiciels distribués en .img ou .ima.

Avec QEMU

Ajoute simplement l'option -fda (floppy A:) au lancement :

qemu-system-i386 -m 64 -hda freedos.qcow2 -fda jeu.img -boot c

Dans FreeDOS, le contenu sera accessible via A:. Tu peux aussi monter deux disquettes simultanément avec -fda et -fdb.

Avec VirtualBox

Dans Paramètres → Stockage :

Ajoute un contrôleur Floppy s'il n'existe pas
Attache ton fichier .img ou .ima comme lecteur de disquette

Inspecter une image disquette directement sous Linux

Tu peux lire le contenu d'une image avant même de la monter dans la VM :

# Monter en lecture seule sur Linux hôte
sudo mkdir /mnt/floppy
sudo mount -o loop,ro disquette.img /mnt/floppy
ls /mnt/floppy
sudo umount /mnt/floppy

Pour créer une image de disquette vierge formatée FAT12 :

dd if=/dev/zero of=vierge.img bs=512 count=2880  # 1.44 Mo
mkfs.fat -F 12 vierge.img

Partager un dossier entre Linux et FreeDOS

C'est le point souvent bloquant : DOS ne connaît ni les partages réseau modernes, ni les Guest Additions. Voici trois approches qui fonctionnent.

Solution 1 — Image disque partagée (la plus simple avec QEMU)

Crée une image FAT que tu peux monter alternativement sous Linux et sous DOS :

# Créer une image de 100 Mo formatée FAT16
dd if=/dev/zero of=partage.img bs=1M count=100
mkfs.fat -F 16 partage.img

Côté Linux, pour y déposer des fichiers :

sudo mount -o loop partage.img /mnt/partage
sudo cp mon_programme.exe /mnt/partage/
sudo umount /mnt/partage

Côté QEMU, attache-la comme second disque :

qemu-system-i386 -m 64 -hda freedos.qcow2 -hdb partage.img -boot c

Dans FreeDOS, elle apparaîtra en D:.

⚠️ Évite d'écrire des deux côtés en même temps — démonte toujours du côté Linux avant de lancer la VM.

Solution 2 — Dossier partagé via QEMU `-drive` avec VVFAT

QEMU peut exposer un dossier Linux comme un disque FAT virtuel, sans avoir à le monter :

qemu-system-i386 -m 64 -hda freedos.qcow2 \
  -drive file=fat:rw:/home/utilisateur/dossier_partage,format=raw

Le dossier dossier_partage apparaît comme un disque dans FreeDOS. Pratique mais à utiliser avec précaution : le mode rw (lecture/écriture) peut corrompre des fichiers si la VM crashe.

Solution 3 — Dossiers partagés VirtualBox

VirtualBox propose nativement des Shared Folders, mais ils ne fonctionnent pas directement sous DOS (pas de Guest Additions DOS). Il faut passer par un pilote tiers comme VBSF for DOS ou simplement utiliser la solution 1 (image disque attachée).

Astuces utiles

Transférer des fichiers ponctuellement : crée une ISO contenant tes fichiers et monte-la comme CD-ROM dans la VM :

mkisofs -o transfert.iso -J -R /chemin/vers/fichiers

Snapshots QEMU pour expérimenter sans risque :

qemu-img snapshot -c avant_test freedos.qcow2
# ... après expérimentation ratée :
qemu-img snapshot -a avant_test freedos.qcow2

Réseau dans FreeDOS : possible avec le paquet mTCP inclus dans FreeDOS — utile pour FTP, Telnet, ou IRC depuis ta VM.

Note sur la taille de l'image

Une image FreeDOS complète pèse environ 230 Mio, bien plus qu'une disquette 3,5" de 1,44 Mo. C'est parce qu'elle inclut un installateur, des utilitaires, des pilotes, et des programmes optionnels. L'installation finale sur disque peut tenir en moins de 20 Mo si tu sélectionnes uniquement le strict nécessaire (kernel + COMMAND.COM + quelques utilitaires).

À titre de comparaison historique : disquette 5,25" originale = 160 Ko, disquette 3,5" HD = 1,44 Mo, première version de MS-DOS = tenait sur une seule disquette.

Optimisation de la mémoire EMS/XMS sous DOS

DOS a été conçu à une époque où 640 Ko de RAM semblaient infinis. Cette limite — la fameuse conventional memory — est devenue un casse-tête dès que les programmes ont grossi. Comprendre les différents types de mémoire est essentiel pour faire tourner correctement les vieux jeux et logiciels.

Les différents types de mémoire

Conventional memory (0 – 640 Ko) : la mémoire de base utilisable par tous les programmes DOS. C'est la ressource la plus précieuse — beaucoup de jeux exigent 580 Ko ou plus de libre.

Upper Memory Area / UMA (640 Ko – 1 Mo) : zone réservée au BIOS et aux périphériques, mais avec des "trous" (UMB, Upper Memory Blocks) où l'on peut loger des pilotes pour libérer la mémoire conventionnelle.

High Memory Area / HMA (1024 – 1088 Ko) : les premiers 64 Ko au-dessus de 1 Mo, accessibles en mode réel grâce à une astuce du 80286. On y charge typiquement une partie de DOS.

Extended Memory / XMS (au-delà de 1 Mo) : mémoire linéaire au-delà du premier mégaoctet, gérée par HIMEM.SYS. Utilisée par Windows 3.x, les jeux récents (Doom, Quake DOS), les disques RAM et caches.

Expanded Memory / EMS : ancien système de pagination (fenêtre de 64 Ko qui pointe vers une grande zone de RAM). Demandé par des jeux et logiciels plus anciens (Ultima 7, Wing Commander, Lotus 1-2-3). Émulé via EMM386.EXE à partir de la mémoire étendue.

Configuration recommandée pour FreeDOS

Édite (ou crée) le fichier C:\FDCONFIG.SYS — l'équivalent de CONFIG.SYS sous FreeDOS :

DOS=HIGH,UMB
DEVICE=C:\FREEDOS\BIN\HIMEM.EXE
DEVICE=C:\FREEDOS\BIN\EMM386.EXE RAM
DEVICEHIGH=C:\FREEDOS\BIN\ANSI.SYS
FILES=40
BUFFERS=20
STACKS=9,256
SHELL=C:\FREEDOS\BIN\COMMAND.COM /E:512 /P

Explication ligne par ligne :

DOS=HIGH,UMB : charge le noyau DOS dans la HMA et active l'usage des UMB
HIMEM.EXE : gestionnaire de mémoire XMS, indispensable
EMM386.EXE RAM : active à la fois EMS (émulé) et UMB. Utilise NOEMS à la place si tu n'as besoin que des UMB sans émulation EMS (libère plus de RAM)
DEVICEHIGH= : charge un pilote dans les UMB plutôt qu'en mémoire conventionnelle
SHELL=... /E:512 : agrandit l'environnement DOS à 512 octets (utile pour les chemins longs)

Et dans C:\AUTOEXEC.BAT, charge les TSR (programmes résidents) en mémoire haute avec LH (LoadHigh) :

@ECHO OFF
SET PATH=C:\FREEDOS\BIN;C:\
SET TEMP=C:\TEMP
LH C:\FREEDOS\BIN\SHARE.EXE
LH C:\FREEDOS\BIN\MOUSE.EXE
PROMPT $P$G

Vérifier le résultat

La commande MEM (ou MEM /C pour le détail par programme) affiche la répartition mémoire :

C:\> MEM /C /P

Tu devrais voir quelque chose comme :

Memory Type        Total     Used     Free
----------------  -------  -------  -------
Conventional       640K      35K     605K
Upper              155K      48K     107K
Reserved           384K     384K       0K
Extended (XMS)   15,232K   1,088K  14,144K
----------------  -------  -------  -------
Total memory     16,411K   1,555K  14,856K

Largest executable program size      605K  (619,328 bytes)
Largest free upper memory block      107K  (109,568 bytes)

L'objectif : maximiser le "Largest executable program size" (idéalement >600 Ko).

Choix EMS vs XMS selon les jeux

Logiciel typique	Besoin
Doom, Quake, Duke Nukem 3D	XMS uniquement → `EMM386 NOEMS`
Ultima 7, Wing Commander, Master of Orion	EMS requis → `EMM386 RAM`
Lotus 1-2-3, AutoCAD ancien	EMS recommandé
Commander Keen, Prince of Persia	Aucun → désactiver EMM386

Astuce : maintiens deux fichiers de config différents et utilise le menu de démarrage de FreeDOS (!menu dans FDCONFIG.SYS) pour choisir au boot — exactement comme on faisait dans les années 90.

Script de lancement automatisé pour QEMU

Plutôt que retaper de longues commandes QEMU, voici un script Bash complet et paramétrable.

Script principal

Crée le fichier ~/bin/freedos-vm.sh :

#!/usr/bin/env bash
#
# Lanceur FreeDOS sous QEMU
# Usage : freedos-vm.sh [commande] [options]
#

set -euo pipefail

# --- Configuration ---------------------------------------------------------
VM_DIR="${HOME}/VMs/freedos"
DISK="${VM_DIR}/freedos.qcow2"
ISO="${VM_DIR}/FD13LIVE.iso"
SHARE_DIR="${VM_DIR}/partage"
SHARE_IMG="${VM_DIR}/partage.img"
FLOPPY_DIR="${VM_DIR}/floppies"

RAM="64"                  # Mo de RAM
DISK_SIZE="2G"            # Taille du disque dur virtuel
SHARE_SIZE_MB="100"       # Taille de l'image de partage en Mo

QEMU="qemu-system-i386"
QEMU_OPTS=(
  -m "${RAM}"
  -rtc base=localtime         # Horloge synchronisée
  -vga std                    # Carte graphique standard
  -display gtk                # Remplace par "sdl" si besoin
)

# --- Couleurs --------------------------------------------------------------
RED=$'\033[0;31m'; GRN=$'\033[0;32m'; YEL=$'\033[1;33m'; NC=$'\033[0m'

log()  { echo "${GRN}[+]${NC} $*"; }
warn() { echo "${YEL}[!]${NC} $*"; }
err()  { echo "${RED}[x]${NC} $*" >&2; exit 1; }

# --- Fonctions -------------------------------------------------------------
init() {
    log "Initialisation de l'environnement dans ${VM_DIR}"
    mkdir -p "${VM_DIR}" "${SHARE_DIR}" "${FLOPPY_DIR}"

    if [[ ! -f "${DISK}" ]]; then
        log "Création du disque dur virtuel (${DISK_SIZE})"
        qemu-img create -f qcow2 "${DISK}" "${DISK_SIZE}"
    else
        warn "Le disque ${DISK} existe déjà"
    fi

    if [[ ! -f "${SHARE_IMG}" ]]; then
        log "Création de l'image de partage (${SHARE_SIZE_MB} Mo, FAT16)"
        dd if=/dev/zero of="${SHARE_IMG}" bs=1M count="${SHARE_SIZE_MB}" status=none
        mkfs.fat -F 16 -n PARTAGE "${SHARE_IMG}" >/dev/null
    fi

    if [[ ! -f "${ISO}" ]]; then
        warn "ISO FreeDOS absente. Télécharge-la depuis https://www.freedos.org/download/"
        warn "puis place-la ici : ${ISO}"
    fi
}

install() {
    [[ -f "${ISO}" ]] || err "ISO manquante : ${ISO}"
    log "Démarrage en mode INSTALLATION (boot CD)"
    "${QEMU}" "${QEMU_OPTS[@]}" \
        -hda "${DISK}" \
        -cdrom "${ISO}" \
        -boot d
}

run() {
    local floppy="${1:-}"
    local qemu_extra=()

    if [[ -n "${floppy}" ]]; then
        [[ -f "${floppy}" ]] || err "Disquette introuvable : ${floppy}"
        log "Disquette montée en A: : ${floppy}"
        qemu_extra+=(-fda "${floppy}")
    fi

    log "Démarrage de FreeDOS"
    "${QEMU}" "${QEMU_OPTS[@]}" \
        -hda "${DISK}" \
        -hdb "${SHARE_IMG}" \
        "${qemu_extra[@]}" \
        -boot c
}

mount_share() {
    local mp="/tmp/freedos-share-$$"
    sudo mkdir -p "${mp}"
    sudo mount -o loop,uid="$(id -u)",gid="$(id -g)" "${SHARE_IMG}" "${mp}"
    log "Image de partage montée sur ${mp}"
    log "N'oublie pas de démonter avec : sudo umount ${mp} && rmdir ${mp}"
}

umount_share() {
    for mp in /tmp/freedos-share-*; do
        [[ -d "${mp}" ]] || continue
        sudo umount "${mp}" && sudo rmdir "${mp}" && log "Démonté : ${mp}"
    done
}

snapshot() {
    local name="${1:?nom de snapshot requis}"
    qemu-img snapshot -c "${name}" "${DISK}"
    log "Snapshot '${name}' créé"
}

restore() {
    local name="${1:?nom de snapshot requis}"
    qemu-img snapshot -a "${name}" "${DISK}"
    log "Snapshot '${name}' restauré"
}

list_snapshots() {
    qemu-img snapshot -l "${DISK}"
}

usage() {
    cat <<EOF
Usage : $(basename "$0") <commande> [arguments]

Commandes :
  init              Crée disque, image de partage et arborescence
  install           Lance la VM en mode installation (boot ISO)
  run [disquette]   Démarre FreeDOS (avec disquette optionnelle en A:)
  mount             Monte l'image de partage côté Linux
  umount            Démonte toutes les images de partage
  snap <nom>        Crée un snapshot du disque
  restore <nom>     Restaure un snapshot
  snaps             Liste les snapshots
  help              Affiche cette aide

Exemples :
  $(basename "$0") init
  $(basename "$0") install
  $(basename "$0") run
  $(basename "$0") run ${FLOPPY_DIR}/jeu.img
  $(basename "$0") snap avant_test_doom
EOF
}

# --- Dispatcher ------------------------------------------------------------
cmd="${1:-help}"
shift || true

case "${cmd}" in
    init)     init ;;
    install)  install ;;
    run)      run "${@:-}" ;;
    mount)    mount_share ;;
    umount)   umount_share ;;
    snap)     snapshot "$@" ;;
    restore)  restore "$@" ;;
    snaps)    list_snapshots ;;
    help|-h|--help) usage ;;
    *)        err "Commande inconnue : ${cmd}. Voir '$(basename "$0") help'" ;;
esac

Rends-le exécutable :

chmod +x ~/bin/freedos-vm.sh

Utilisation typique

# Première fois : crée l'arborescence et les disques
freedos-vm.sh init

# Télécharge l'ISO depuis freedos.org et place-la dans ~/VMs/freedos/

# Lance l'installation
freedos-vm.sh install

# Démarrages quotidiens
freedos-vm.sh run

# Tester un jeu sur disquette
freedos-vm.sh run ~/VMs/freedos/floppies/keen1.img

# Avant une manip risquée
freedos-vm.sh snap config_stable
# ...si ça casse :
freedos-vm.sh restore config_stable

# Copier des fichiers depuis Linux vers FreeDOS
freedos-vm.sh mount
cp ~/Downloads/programme.zip /tmp/freedos-share-*/
freedos-vm.sh umount
freedos-vm.sh run

Variante avec dossier partagé direct (VVFAT)

Pour éviter le mount/umount manuel, remplace la ligne -hdb "${SHARE_IMG}" par :

-drive file=fat:rw:"${SHARE_DIR}",format=raw,if=ide

Le dossier ~/VMs/freedos/partage est alors directement vu comme un disque dans FreeDOS, sans démontage. Attention : en cas de crash brutal de la VM, le contenu peut être corrompu — à réserver pour des transferts ponctuels.

Raccourci bureau (optionnel)

Crée ~/.local/share/applications/freedos.desktop :

[Desktop Entry]
Name=FreeDOS VM
Comment=Démarrer la machine virtuelle FreeDOS
Exec=/home/UTILISATEUR/bin/freedos-vm.sh run
Icon=computer
Terminal=false
Type=Application
Categories=System;Emulator;

Remplace UTILISATEUR par ton nom d'utilisateur. FreeDOS apparaîtra alors dans le menu d'applications de ton bureau.

Émulation SoundBlaster sous QEMU

Sans son, un vieux jeu DOS perd la moitié de son charme — les bips de Doom, la musique MIDI de Monkey Island, les sample digitalisés de Wing Commander font partie de l'expérience. QEMU peut émuler plusieurs cartes son de l'époque, et FreeDOS dispose des pilotes nécessaires pour les exploiter.

Les cartes son émulées par QEMU

QEMU propose plusieurs modèles. Pour DOS, seuls quelques-uns sont pertinents :

Option QEMU	Carte émulée	Compatibilité DOS
`sb16`	SoundBlaster 16	★★★ Excellente — le standard de facto
`adlib`	AdLib (Yamaha YM3812)	★★ Bonne pour les jeux pré-1992 (musique FM uniquement)
`gus`	Gravis UltraSound	★ Limité, peu de jeux le supportent nativement
`pcspk`	Haut-parleur interne PC	★★★ Toujours dispo, son bipé d'origine
`cs4231a`	Windows Sound System	À éviter sous DOS

Recommandation : utilise sb16 qui couvre 95% des jeux DOS et inclut une émulation AdLib intégrée (donc compatibilité descendante avec les jeux plus anciens).

Activation dans QEMU

Ajoute les options audio au lancement. La syntaxe a évolué entre les versions de QEMU — voici la forme moderne (QEMU ≥ 5.0) :

qemu-system-i386 \
  -m 64 \
  -hda freedos.qcow2 \
  -audiodev pa,id=snd0 \
  -machine pcspk-audiodev=snd0 \
  -device sb16,audiodev=snd0 \
  -boot c

Explication des options :

-audiodev pa,id=snd0 : backend audio PulseAudio (utilise alsa pour ALSA pur, pipewire sur les distros récentes, oss pour OSS)
-machine pcspk-audiodev=snd0 : active le haut-parleur interne
-device sb16,audiodev=snd0 : ajoute la carte SoundBlaster 16

Pour la SoundBlaster + AdLib simultanément (utile pour les jeux qui détectent les deux séparément) :

-device sb16,audiodev=snd0 \
-device adlib,audiodev=snd0

Adapter le script de lancement

Reprends le script freedos-vm.sh de la section précédente et modifie le tableau QEMU_OPTS :

# Détection automatique du backend audio
detect_audio() {
    if command -v pipewire &>/dev/null && pgrep -x pipewire &>/dev/null; then
        echo "pipewire"
    elif pgrep -x pulseaudio &>/dev/null; then
        echo "pa"
    else
        echo "alsa"
    fi
}

AUDIO_BACKEND="$(detect_audio)"

QEMU_OPTS=(
  -m "${RAM}"
  -rtc base=localtime
  -vga std
  -display gtk
  -audiodev "${AUDIO_BACKEND},id=snd0"
  -machine "pcspk-audiodev=snd0"
  -device sb16,audiodev=snd0
)

Le script choisira automatiquement PipeWire, PulseAudio ou ALSA selon ce qui tourne sur ton système.

Configuration côté FreeDOS

Pour que les jeux trouvent la SoundBlaster, il faut définir la variable d'environnement BLASTER dans AUTOEXEC.BAT. C'est la convention historique que tous les jeux DOS lisent au démarrage.

Ajoute cette ligne :

SET BLASTER=A220 I5 D1 H5 T6

Décodage des paramètres :

Paramètre	Signification	Valeur émulée par QEMU
`A220`	Port d'E/S de base	`0x220` (standard)
`I5`	IRQ	`5` (parfois `7`)
`D1`	Canal DMA 8 bits	`1`
`H5`	Canal DMA 16 bits	`5` (SB16 uniquement)
`T6`	Type de carte	`6` = SoundBlaster 16

Tu peux aussi ajouter le port MIDI/MPU-401 si tu en as besoin :

SET BLASTER=A220 I5 D1 H5 T6 P330
SET MIDI=SYNTH:1 MAP:E MODE:0

Configuration des jeux

La plupart des jeux DOS ont un programme de configuration audio à lancer une fois (SETUP.EXE, INSTALL.EXE, SETSOUND.EXE selon le titre). Choisis :

Effets sonores : SoundBlaster 16 ou SoundBlaster Pro
Musique : SoundBlaster 16 (pour OPL3) ou General MIDI via MPU-401 si tu veux la qualité supérieure

Pour les jeux qui demandent un test, le programme jouera un échantillon — si tu l'entends, c'est gagné.

Test rapide après installation

Sous FreeDOS, le paquet officiel inclut souvent un petit utilitaire de test. Sinon, télécharge un module .MOD et lance un player comme MODPLAY ou DOSMID pour les fichiers MIDI :

C:\> MODPLAY musique.mod

Tu peux aussi simplement lancer un jeu connu pour son audio : Doom, Duke Nukem 3D, Commander Keen 4 → ils détecteront la SB16 et joueront leurs musiques OPL3.

Problèmes courants

Pas de son du tout :

Vérifie que BLASTER est bien défini : SET dans le prompt DOS doit l'afficher
Lance QEMU avec -d guest_errors pour voir les éventuelles erreurs d'I/O
Teste le backend : remplace pa par alsa ou inversement

Son saccadé ou crachotant :

Augmente la RAM allouée (-m 128)
Ajoute -cpu pentium pour ralentir l'émulation CPU (certains jeux audio sont sensibles à la vitesse)
Sur des distros avec PipeWire récent, essaie -audiodev pipewire,id=snd0

Musique sans effets, ou inverse :

Le jeu utilise probablement deux périphériques séparés (AdLib pour la musique, SB pour les SFX) → ajoute -device adlib,audiodev=snd0 en plus

Tempo MIDI trop rapide/lent :

Bien configurer la variable BLASTER avec le bon IRQ et port MPU-401 (P330)

Pour aller plus loin : DOSBox vs QEMU

Soyons honnête : pour le jeu DOS pur, DOSBox (et surtout son fork DOSBox-X ou DOSBox Staging) offre une émulation audio bien plus fidèle que QEMU — émulation cycle-accurate du Yamaha OPL3, support natif MT-32, General MIDI logiciel intégré, etc.

QEMU reste préférable quand :

Tu veux un vrai environnement DOS complet (multitâche avec FreeDOS, accès réseau via mTCP, snapshots disque)
Tu fais autre chose que jouer (développement, BIOS flashing, scripts batch)
Tu veux une VM persistante et configurable comme un vrai PC

Pour le jeu, l'approche hybride est gagnante : FreeDOS sous QEMU pour explorer et bidouiller, DOSBox Staging pour lancer un jeu spécifique avec le meilleur son possible.

Bibliographie

Site officiel : https://www.freedos.org/
Wiki d'installation VirtualBox : https://wiki.freedos.org/wiki/index.php/VirtualBox
Documentation QEMU : https://www.qemu.org/docs/master/system/index.html
mTCP (réseau sous DOS) : https://www.brutman.com/mTCP/

22 KiB Raw Blame History Unescape Escape