Trois projets soutenus par Google présentés en première au 83e Festival international du film de Venise

Trois projets soutenus par Google font leur première au 83e Festival international du film de Venise

Le 11 septembre 2026, Google a publié une annonce sur son blog IA indiquant que trois projets soutenus par Google avaient été présentés en première lors du 83e Festival international du film de Venise. L'article est classé dans la rubrique technologies XR et AR du blog, et il reste l'unique source primaire à l'origine de cet article.

C'est un fait compact et bien délimité, qui mérite d'être traité avec la même discipline que n'importe quel autre compte rendu technique. Les annonces de ce type ont tendance à attirer les spéculations : quels projets, construits avec quoi, exécutés sur quel matériel, et accessibles à qui ensuite. Presque rien de tout cela n'est établi par la source disponible ici. Cet article fait donc deux choses. Premièrement, il énonce exactement ce que confirme la source primaire, et où les preuves s'arrêtent. Deuxièmement, parce que l'annonce se situe dans le flux de couverture XR et AR de Google, il fournit une configuration technique reproductible pour le travail pratique qui entoure les projets immersifs : empaquetage, validation et prévisualisation de livrables WebXR dans un navigateur.

Les sections techniques ci-dessous constituent un exemple de travail indépendant. Elles ne décrivent pas les trois projets présentés en première, dont les outils et les pipelines ne sont pas établis par la source.

Ce que confirme la source primaire

Le contenu vérifié de l'annonce est limité et peut être énuméré sans risque de déformation :

• Trois projets soutenus par Google ont été présentés en première lors du 83e Festival international du film de Venise.
• Google a publié l'annonce sur son propre blog le 11 septembre 2026.
• L'article apparaît dans la catégorie technologies XR et AR du blog.
• L'emplacement canonique de l'article est https://blog.google/innovation-and-ai/technology/xr-ar/three-google-supported-projects-premiere-during-the-83rd-venice-international-film-festival.

Tout le reste — titres, créateurs, durée, modèles de casque, choix de moteur, structures de financement ou plans de distribution après le festival — est soit absent de l'extrait vérifié, soit propre à la page source elle-même. Lorsque ce type de détail importe, la bonne démarche est de lire directement l'article original plutôt que de le reconstruire à partir d'un résumé.

Ce que la source n'établit pas

Être explicite sur les lacunes n'est pas de la pédanterie ; c'est ce qui distingue une note utilisable d'une rumeur.

Dans le matériel vérifié disponible ici, l'annonce n'établit pas :

1. Les noms des trois projets ni les studios, artistes et groupes de recherche qui les portent.
2. Ce que signifie « soutenu » dans ce contexte — financement, assistance technique, accès au matériel ou partenariat de production sont tous plausibles et aucun n'est confirmé.
3. La pile technique de l'un des projets, y compris si WebXR, un moteur de jeu ou un runtime sur mesure a été utilisé.
4. Le format d'exposition au festival, comme une installation avec visiocasque, une projection, une œuvre AR mobile ou une projection conventionnelle.
5. La disponibilité après le festival, y compris diffusion en streaming, expositions itinérantes ou dépôts publics.

Tout article qui fournit ces détails sans renvoyer à la source devine. Celui-ci ne le fait pas.

Lire le classement XR/AR sans surinterprétation

Le libellé de catégorie est une métadonnée, pas une affirmation technique. Un article classé en XR et AR nous indique où Google a choisi de placer le sujet dans sa propre taxonomie ; il ne nous dit pas ce que contiennent les projets. Cela dit, ce classement est un signal raisonnable que l'annonce concerne un travail immersif ou de réalité étendue plutôt que, disons, une production 2D purement conventionnelle. Cette inférence doit être étiquetée comme une inférence.

Ce qui peut être affirmé avec davantage de certitude relève de la structure. Les festivals sont devenus l'un des rares lieux où le travail immersif atteint un public en dehors du salon d'un propriétaire de casque, car ils fournissent le matériel, la supervision et un public à des horaires définis. Cela fait des festivals un canal de diffusion aux contraintes inhabituelles : créneaux horaires limités, matériel fixe, aucun processus de validation d'app store, et souvent aucune seconde chance si une version échoue sur place.

Pour les équipes dans cet environnement, le goulot d'étranglement technique est rarement l'idée créative. C'est le pipeline de livraison — faire en sorte qu'une scène se charge de manière fiable, sur du matériel que vous n'avez pas choisi, dans une fenêtre que vous ne pouvez pas prolonger. La livraison immersive basée sur navigateur, généralement via WebXR, est attrayante précisément parce qu'elle supprime le cycle de validation des boutiques et fonctionne sur du matériel déjà présent dans la salle. Le reste de cet article construit un environnement minimal et reproductible pour ce travail.

Prérequis

Avant de commencer, confirmez que les éléments suivants sont disponibles sur votre poste de travail :

• Node.js 20 LTS ou version ultérieure avec npm, utilisé pour l'outillage de build et la CLI d'assets.
• Python 3.10 ou version ultérieure, utilisé pour les scripts de validation et de manifeste.
• Un navigateur compatible WebXR sur ordinateur pour les premières vérifications, par exemple un navigateur récent basé sur Chromium.
• En option, un casque autonome ou relié avec un navigateur qui prend en charge les sessions immersives.
• Git, afin que le projet puisse être committé et relu.
• Accès réseau au registre npm pendant l'installation.

Aucun casque n'est requis pour accomplir les étapes d'installation ; le parcours de prévisualisation sur ordinateur fonctionne sans.

Installation étape par étape

1. Vérifier la chaîne d'outils

Confirmez les versions de Node.js et de npm avant de générer quoi que ce soit, car le modèle Vite attend un runtime moderne.

node --version
npm --version

Confirmez également l'interpréteur Python ; le script de validation n'utilise que la bibliothèque standard, donc aucun paquet d'environnement virtuel n'est strictement requis.

python3 --version

2. Générer la structure du projet

Créez un projet Vite minimal dans un nouveau répertoire. L'option --template vanilla produit un projet JavaScript simple sans framework, ce qui réduit la surface à examiner.

npm create vite@latest immersive-review -- --template vanilla
cd immersive-review
npm install

3. Ajouter les dépendances d'exécution et de développement

Installez three.js, qui fournit le moteur de rendu WebGL et les assistants WebXR utilisés dans la scène de prévisualisation.

npm install three

Installez le plugin SSL de base pour que le serveur de développement puisse servir en HTTPS. C'est important car les sessions WebXR exigent un contexte sécurisé, et un casque qui se connecte via le réseau local ne considérera pas une adresse HTTP simple comme sécurisée.

npm install --save-dev @vitejs/plugin-basic-ssl

Installez la CLI glTF Transform, qui est utilisée plus loin pour inspecter et optimiser les assets glTF binaires avant leur livraison.

npm install --save-dev @gltf-transform/cli

Créez les dossiers qui contiennent les assets publics et le code source de l'application.

mkdir -p public/assets src

4. Configurer le serveur de développement

Remplacez le vite.config.js généré par la configuration suivante. Le réglage host: true expose le serveur sur le réseau local afin qu'un casque puisse l'atteindre, et le plugin SSL fournit le certificat qui rend l'origine sécurisée.

import { defineConfig } from 'vite';
import basicSsl from '@vitejs/plugin-basic-ssl';

export default defineConfig({
  plugins: [basicSsl()],
  server: {
    host: true,   // reachable from a headset on the same network
    https: true,  // WebXR requires a secure context
  },
});

5. Ajouter une scène de prévisualisation WebXR minimale

Écrivez ce qui suit dans src/main.js. Cela crée un moteur de rendu avec XR activé, ajoute le bouton d'entrée VR standard et anime un seul cube afin que le suivi de tête et le rendu stéréo puissent être vérifiés rapidement.

import * as THREE from 'three';
import { VRButton } from 'three/addons/webxr/VRButton.js';

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.xr.enabled = true;
renderer.setPixelRatio(window.devicePixelRatio);
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
document.body.appendChild(VRButton.createButton(renderer));

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerHeight, 0.1, 20);

const cube = new THREE.Mesh(
  new THREE.BoxGeometry(0.5, 0.5, 0.5),
  new THREE.MeshStandardMaterial({ color: 0x4285f4 })
);
cube.position.set(0, 1.5, -1);
scene.add(cube);
scene.add(new THREE.HemisphereLight(0xffffff, 0x444444, 1.2));

renderer.setAnimationLoop(() => {
  cube.rotation.y += 0.005;
  renderer.render(scene, camera);
});

Assurez-vous que index.html charge le point d'entrée du module ; le modèle Vite inclut déjà la balise correcte.

<script type="module" src="/src/main.js"></script>

6. Ajouter un validateur glTF binaire

Les fichiers glTF binaires commencent par un en-tête fixe et un chunk JSON. Le script suivant vérifie directement cette structure, ce qui permet de détecter les téléchargements tronqués et les fichiers renommés en .glb sans avoir été convertis. Enregistrez-le sous validate_glb.py.

import json
import struct
import sys
from pathlib import Path

MAGIC = b"glTF"


def inspect_glb(path: str) -> dict:
    data = Path(path).read_bytes()
    magic, version, length = struct.unpack_from("<4sII", data, 0)
    if magic != MAGIC:
        raise ValueError(f"{path} is not a binary glTF file")
    if length != len(data):
        raise ValueError(f"{path}: header length {length} != file size {len(data)}")
    chunk_len, chunk_type = struct.unpack_from("<I4s", data, 12)
    if chunk_type != b"JSON":
        raise ValueError(f"{path}: first chunk is not JSON")
    doc = json.loads(data[20:20 + chunk_len].decode("utf-8"))
    return {
        "version": version,
        "asset_version": doc.get("asset", {}).get("version"),
        "meshes": len(doc.get("meshes", [])),
        "materials": len(doc.get("materials", [])),
    }


if __name__ == "__main__":
    print(inspect_glb(sys.argv[1]))

7. Ajouter un générateur de manifeste d'assets

Générez un manifeste de sommes de contrôle pour chaque asset du bundle de revue. Cela donne aux relecteurs un moyen de confirmer que la version qu'ils ont visionnée est celle qui a été soumise. Enregistrez-le sous build_manifest.py.

import hashlib
import json
from pathlib import Path

ROOT = Path("public/assets")
EXTENSIONS = {".glb", ".gltf", ".usdz", ".ktx2", ".mp4", ".webm"}


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1 << 20), b""):
            digest.update(chunk)
    return digest.hexdigest()


manifest = {
    path.relative_to(ROOT).as_posix(): {
        "bytes": path.stat().st_size,
        "sha256": sha256(path),
    }
    for path in sorted(ROOT.rglob("*"))
    if path.is_file() and path.suffix.lower() in EXTENSIONS
}

Path("asset-manifest.json").write_text(json.dumps(manifest, indent=2))
print(f"Wrote {len(manifest)} entries")

Exemples d'utilisation

Prévisualiser la scène en local

Démarrez le serveur de développement. Vite affiche à la fois une adresse locale et une adresse réseau ; l'adresse réseau est celle qu'un casque peut ouvrir.

npm run dev

Ouvrez l'URL HTTPS affichée sur le navigateur de l'ordinateur. Un bouton « Enter VR » apparaît en bas de la page. Sur un casque, ouvrez la même URL réseau dans le navigateur de l'appareil et sélectionnez le bouton pour démarrer une session immersive.

Pour vérifier la prise en charge des sessions par programmation avant de solliciter l'utilisateur, ajoutez l'extrait suivant à l'application. L'appel isSessionSupported se résout en un booléen et ne nécessite pas que l'utilisateur accorde une autorisation.

if (navigator.xr) {
  const supported = await navigator.xr.isSessionSupported('immersive-vr');
  console.log('immersive-vr supported:', supported);
}

Valider un asset avant sa livraison

Exécutez le validateur sur n'importe quel fichier .glb du bundle. Une exécution réussie affiche la version ainsi qu'un nombre de maillages et de matériaux ; un échec lève une erreur claire décrivant quelle vérification structurelle a échoué.

python validate_glb.py public/assets/scene.glb

Pour un rapport structurel plus approfondi, incluant les tailles de textures et le nombre d'animations, utilisez la CLI glTF Transform.

npx gltf-transform inspect public/assets/scene.glb

Pour produire une version de revue plus légère, exécutez l'optimiseur. Il réécrit le fichier vers un nouveau chemin de sortie afin que l'original soit conservé pour comparaison.

npx gltf-transform optimize public/assets/scene.glb public/assets/scene.review.glb --texture-compress webp

Générer un manifeste de revue

Générez le manifeste de sommes de contrôle après finalisation des assets et committez le JSON obtenu aux côtés de la source. Les relecteurs peuvent ensuite relancer le script et comparer les hachages pour confirmer que la version visionnée correspond à celle soumise.

python build_manifest.py

Reproduire le pipeline en intégration continue

Les deux scripts Python se terminent avec un statut non nul lorsqu'une assertion échoue, ils peuvent donc être intégrés à n'importe quelle tâche CI disposant d'un interpréteur Python.

python validate_glb.py public/assets/scene.glb && python build_manifest.py

Limites et notes de validation

Trois limites pratiques méritent d'être énoncées clairement.

Premièrement, la vérification de l'en-tête glTF ne valide que la structure du conteneur. Elle confirme que le fichier est un glTF binaire bien formé et que sa longueur déclarée correspond à sa taille réelle. Elle ne valide ni la géométrie, ni les graphes de matériaux, ni si un moteur de rendu dessinera correctement la scène. L'étape d'inspection glTF Transform couvre davantage de terrain, mais ne remplace toujours pas un test sur le matériel cible.

Deuxièmement, le plugin SSL utilisé ici est une commodité de développement. Il génère un certificat auto-signé, ce dont les navigateurs avertiront, et il ne convient pas à un déploiement public. L'hébergement de production doit utiliser un certificat provenant d'une autorité de confiance.

Troisièmement, la scène de prévisualisation est délibérément minimale. Elle existe pour confirmer qu'un casque peut établir une session et que les assets se chargent, non pour représenter une approche artistique ou technique particulière.

Appliquée à l'annonce elle-même, la même discipline s'impose. Le fait vérifié est que trois projets soutenus par Google ont été présentés en première au 83e Festival international du film de Venise, annoncé par Google le 11 septembre 2026 dans sa catégorie XR et AR. Tout le reste appartient à la page source et aux propres équipes des projets. Traiter le libellé de catégorie comme une hypothèse plutôt que comme une conclusion garde le reportage honnête, et construire un petit pipeline de validation reproductible rend le travail technique digne de confiance.

Conclusion

La première à Venise est un jalon qui mérite d'être consigné avec précision : trois projets soutenus, un festival, une annonce datée, une source primaire. Là où les preuves sont minces, la contribution utile n'est pas la spéculation mais une frontière claire — plus des outils qui aident le prochain projet immersif à être livré sans surprises. La configuration décrite ci-dessus s'installe en quelques minutes, fonctionne sans casque et produit deux artefacts qui comptent dans tout cadre de revue : une validation structurelle de chaque asset binaire, et un manifeste de sommes de contrôle qui prouve ce qui a été visionné. Pour les équipes préparant un travail dans l'espace XR et AR, cette combinaison est un avantage modeste mais durable, et elle garde les faits vérifiés sur Venise 2026 exactement là où ils appartiennent : attachés à la source.