diff --git a/data/async_http.py b/data/async_http.py
index 14d3e1d0..6705e1e3 100755
--- a/data/async_http.py
+++ b/data/async_http.py
@@ -31,6 +31,8 @@
 
 import time
 
+import platform
+
 
 #################### la version séquentielle
 import requests
@@ -45,6 +47,9 @@ def sequential(urls):
 import asyncio
 import aiohttp
 
+if platform.system()=='Windows':
+    """Solve RuntimeError: Event loop is closed in Windows"""
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # la première version, qui imprime simplement la fin de chaque url
 async def fetch(url):
@@ -71,6 +76,16 @@ async def fetch2(url, i):
     # par rapport à la première variante mais ce n'est pas important
     return url
 
+# runner
+async def run_fetch(args, urls):
+    # sans option on utilise juste fetch
+    if (not args.details):
+        print(f"Running simple mode (fetch) on {len(urls)} URLs")
+        await asyncio.gather(*(fetch(url) for url in urls))
+
+    else:
+        print(f"Running detail mode (fetch2) on {len(urls)} URLs")
+        await asyncio.gather(*(fetch2(url, i) for i, url in enumerate(urls)))
 
 ####################
 # pour utiliser ce code directement depuis un terminal
@@ -99,7 +114,7 @@ def main():
     args = parser.parse_args()
     urls = args.urls
 
-    loop = asyncio.get_event_loop()
+    #loop = asyncio.get_event_loop()
 
     # mode séquentiel
     if args.sequential:
@@ -111,18 +126,11 @@ def main():
     # mode asynchrone
     else:
 
-        # sans option on utilise juste fetch
-        if (not args.details):
-            print(f"Running simple mode (fetch) on {len(urls)} URLs")
-            jobs = (fetch(url) for url in urls)
-        else:
-            print(f"Running detail mode (fetch2) on {len(urls)} URLs")
-            jobs = (fetch2(url, i) for i, url in enumerate(urls))
         # il n'y a plus qu'à
-        beg = time.time()
-        loop.run_until_complete(asyncio.gather(*jobs))
+        beg = time.time()     
+        asyncio.run(run_fetch(args, urls))
         print(f"duration = {time.time()-beg}s")
 
 
 if __name__ == '__main__':
-    main()
+    main()
\ No newline at end of file
diff --git a/data/players.py b/data/players.py
index 4b4eb38e..b7da50c6 100755
--- a/data/players.py
+++ b/data/players.py
@@ -74,9 +74,8 @@ def main():
     args = parser.parse_args()
     players = predefined[args.groupnb]
 
-    loop = asyncio.get_event_loop()
     try:
-        loop.run_until_complete(players.run())
+        asyncio.run((players.run()))
         sys.exit(0)
     except Exception as e:
         print(f"EMERGENCY {type(e)}, {e}")
diff --git a/w8/w8-s2-av-code.html b/w8/w8-s2-av-code.html
index eee27b49..2cf1b6b5 100644
--- a/w8/w8-s2-av-code.html
+++ b/w8/w8-s2-av-code.html
@@ -3,10 +3,20 @@
     font-size: 11px;
 }
 </style>
+
 <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background-color: #eee;">
 <b><i>bloc-note pour copier/coller le code de la vidéo</i></b>
 </h3>
 <hr />
+<!-- Version Python 3.10 -->
+<h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background-color: #eee;">
+<b><i>La vidéo a été tournée avec la 3.6, le cours a été mis à jour pour 3.10.
+Il est préférable d'utiliser les fonctions asyncio de haut niveau, telles qu'asyncio.run().
+Le référencement de l'objet boucle ou l'appel de ses méthodes s'adresse principalement aux auteurs de code,
+de bibliothèques et de frameworks de niveau inférieur, qui ont besoin d'un contrôle plus fin du comportement de la boucle d'événement.
+</i></b>
+</h3>
+<hr />
 <blockquote>
 <p>Prendre l’éditeur IDLE et faire nouveau fichier</p>
 </blockquote>
@@ -23,6 +33,15 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
     
     print(message, &quot;fin&quot;)
     return f'{message} par morceaux'
+
+<!-- add coroutines -->
+async def main():
+    L = await asyncio.gather(
+        morceaux("run 1"),
+        morceaux("run 2"),
+    )
+    print(L)
+
 </code></pre>
 <blockquote>
 <p>Faire Save As &quot;w8s2 Vidéo.py&quot; puis F5</p>
@@ -31,13 +50,9 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 
 morceaux(&quot;run&quot;)
 
-loop = asyncio.get_event_loop()
-
-loop.run_until_complete(morceaux(&quot;run&quot;))
+asyncio.run(morceaux(&quot;run&quot;))
 
-loop.run_until_complete(
-    asyncio.gather(morceaux(&quot;run1&quot;),
-                   morceaux(&quot;run2&quot;)))
+asyncio.run(main())
 </code></pre>
 <blockquote>
 <p>Reprendre sous IDLE le fichier python et ajouter</p>
@@ -58,14 +73,18 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
     
     print(message, &quot;fin&quot;)
     return f'{message} par famine'
+
+async def main():
+    L = await asyncio.gather(
+        famine("run 1"),
+        famine("run 2"),
+    )
+    print(L)
 </code></pre>
 <blockquote>
 <p>Faire Ctl-s puis F5</p>
 </blockquote>
-<pre><code>loop = asyncio.get_event_loop()
-
-loop.run_until_complete(
-    asyncio.gather(famine(&quot;run1&quot;),
-                   famine(&quot;run2&quot;)))
+<pre><code>
+asyncio.run(main())
 </code></pre>
 </div>
\ No newline at end of file
diff --git a/w8/w8-s4-av-code.html b/w8/w8-s4-av-code.html
index ba7867d6..2b346781 100644
--- a/w8/w8-s4-av-code.html
+++ b/w8/w8-s4-av-code.html
@@ -7,6 +7,15 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 <b><i>bloc-note pour copier/coller le code de la vidéo</i></b>
 </h3>
 <hr />
+<!-- Version Python 3.10 -->
+<h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background-color: #eee;">
+<b><i>La vidéo a été tournée avec la 3.6, le cours a été mis à jour pour 3.10.
+Il est préférable d'utiliser les fonctions asyncio de haut niveau, telles qu'asyncio.run().
+Le référencement de l'objet boucle ou l'appel de ses méthodes s'adresse principalement aux auteurs de code,
+de bibliothèques et de frameworks de niveau inférieur, qui ont besoin d'un contrôle plus fin du comportement de la boucle d'événement.
+</i></b>
+</h3>
+<hr />
 <blockquote>
 <p>Prendre un notebook ou un éditeur python</p>
 </blockquote>
@@ -34,6 +43,11 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 <pre><code>import asyncio
 import aiohttp
 import time
+import platform
+
+if platform.system()=='Windows':
+    """Solve RuntimeError: Event loop is closed in Windows"""
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 urls = [&quot;https://www.irs.gov/pub/irs-pdf/f1040.pdf&quot;,
 		&quot;https://www.irs.gov/pub/irs-pdf/f1040es.pdf&quot;,
@@ -57,10 +71,9 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 <blockquote>
 <p>Faire Ctl-s puis F5</p>
 </blockquote>
-<pre><code>loop = asyncio.get_event_loop()
-
+<pre><code>
 beg = time.time()
-loop.run_until_complete(fetch_urls())
+asyncio.run(fetch_urls())
 print(f&quot;duration = {time.time() - beg}s&quot;)
 </code></pre>
 <blockquote>
@@ -74,9 +87,9 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
                 print(f&quot;{i}&quot;, end=&quot;&quot;)
     return url
 
+async def run_fetch2():
+    await asyncio.gather(*(fetch2(url, i) for i, url in enumerate(urls)))
 
-asyncio.get_event_loop().run_until_complete(
-    asyncio.gather(*(fetch2(url, i) for i, url in enumerate(urls)))
-)
+asyncio.run(run_fetch2())
 </code></pre>
 </div>
\ No newline at end of file
diff --git a/w8/w8-s6-av-code.html b/w8/w8-s6-av-code.html
index 25a9c3fd..fde37cfe 100644
--- a/w8/w8-s6-av-code.html
+++ b/w8/w8-s6-av-code.html
@@ -94,13 +94,22 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
     await asyncio.sleep(2)
     show_timer(&quot;&lt;&lt;&lt; c2&quot;)
 
-asyncio.ensure_future(c1())
+async def main():
+    # Il faut maintenant utiliser get_running_loop à la place de get_event_loop.
+    loop = asyncio.get_running_loop()
+    # On crée un objet future
+    fut = loop.create_future()
+    asyncio.ensure_future(c1())
+    await fut
 
 start_timer()
 
 # interrompre après 2s
 try:
-    asyncio.get_event_loop().run_forever()
+    # run dans un terminal, idle, ipython. dans un notebook remplacer par await main()
+    # asyncio.run() crée toujours une nouvelle boucle d'événements et la ferme à la fin.
+    # Elle doit être utilisée comme point d'entrée principal pour les programmes asynchrones, et ne doit idéalement être appelée qu'une seule fois.
+    asyncio.run(main())
 except KeyboardInterrupt:
     print(&quot;bye&quot;)
 </code></pre>
@@ -111,36 +120,42 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 <blockquote>
 <p>réinitialisation de la boucle</p>
 </blockquote>
-<pre><code>asyncio.set_event_loop(asyncio.new_event_loop())
+<!-- Plus necessaire asyncio.run() gére.
+<pre><code>asyncio.set_event_loop(asyncio.new_event_loop()) -->
 </code></pre>
 <blockquote>
 <p>Reprendre le fichier sous IDLE ou votre éditeur python
 et remplacer (après l'utilitaire) par</p>
 </blockquote>
-<pre><code>async def c1_stop():
+<pre><code>async def c1_stop(fut):
     show_timer(&quot;&gt;&gt;&gt; c1&quot;)
     await asyncio.sleep(1)
     show_timer(&quot;forking&quot;)
     # fork
-    asyncio.ensure_future(c2_stop())
+    asyncio.ensure_future(c2_stop(fut))
     await asyncio.sleep(1)
     show_timer(&quot;&lt;&lt;&lt; c1&quot;)
 
 # sera forkée par c1_stop() après une seconde
-async def c2_stop():
+async def c2_stop(fut):
     show_timer(&quot;&gt;&gt;&gt; c2&quot;)
     await asyncio.sleep(2)
     show_timer(&quot;&lt;&lt;&lt; c2&quot;)
-    # attention c'est une méthode bloquante
-    asyncio.get_event_loop().stop()    
+    # On set un résultat pour l'objet future afin de pouvoir quitter la boucle.
+    fut.set_result(&quot;End&quot;)    
 
-asyncio.ensure_future(c1_stop())
+async def main():
+    loop = asyncio.get_running_loop()
+    fut = loop.create_future()
+    asyncio.ensure_future(c1_stop(fut))
+    
+    print(await fut)
 
 start_timer()
 
 # s'arrête tout seul
 try:
-    asyncio.get_event_loop().run_forever()
+    asyncio.run(main())
 except KeyboardInterrupt:
     print(&quot;bye&quot;)
     
diff --git a/w8/w8-s7-av-code.html b/w8/w8-s7-av-code.html
index d170b9d2..383950dd 100644
--- a/w8/w8-s7-av-code.html
+++ b/w8/w8-s7-av-code.html
@@ -10,32 +10,32 @@ <h3 style="border: 1px solid #66b; border-radius: 5px; padding: 10px; background
 <blockquote>
 <p>Prendre un nouveau fichier sous IDLE ou votre éditeur python</p>
 </blockquote>
-<pre><code>from asyncio import (
-    get_event_loop, ensure_future, Task )
+<pre><code>import asyncio
+#Task.all_tasks() et Task.current_task() remplacées par asyncio.all_tasks() et asyncio.current_task()
 
 async def foo():
     pass
 
-task = ensure_future(foo())
+async def main():
+    # On crée une task avec asyncio.create_task() On peut lui donner un nom (option)
+    task = asyncio.create_task(foo(), name=&quot;Foo&quot;)
+    print(&quot;La task Foo est en attente&quot;)
+    print(task)
+    print(&quot;---------&quot;)
+    print(f&quot;Task Foo terminée ? : {task.done()}&quot;) #La task est terminée ?
+    print(&quot;---------&quot;)
+    print(f&quot;Task en cours :\n{asyncio.current_task()}&quot;) # retourne la task en cours.
+    print(&quot;---------&quot;)
+    tasks = asyncio.all_tasks() # retourne un set de tasks non terminées.
+    print(f&quot;Set des tasks non terminées :\n{tasks}&quot;)
+    await task
+    print(&quot;---------&quot;)
+    print(f&quot;Task Foo terminée ? : {task.done()}&quot;) #La task est terminée ?
+    
+asyncio.run(main())
+
 </code></pre>
 <blockquote>
 <p>Faire Save As &quot;w8s7 Vidéo.py&quot; puis F5</p>
 </blockquote>
-<pre><code>task
-</code></pre>
-<blockquote>
-<p>Reprendre le fichier sous IDLE ou votre éditeur python</p>
-</blockquote>
-<pre><code># attention : retourne un set
-tasks = Task.all_tasks()
-</code></pre>
-<blockquote>
-<p>Faire Ctl-s puis F5</p>
-</blockquote>
-<pre><code>tasks
-task in tasks
-
-# et comme on n'est pas dans la  boucle
-print(task.current_task())
-</code></pre>
 </div>
\ No newline at end of file
diff --git a/w8/w8-s8-c2-game.md b/w8/w8-s8-c2-game.md
index a6f11bb1..8a9e2154 100644
--- a/w8/w8-s8-c2-game.md
+++ b/w8/w8-s8-c2-game.md
@@ -14,11 +14,12 @@ jupytext:
     extension: .md
     format_name: myst
 kernelspec:
-  display_name: Python 3
+  display_name: Python 3 (ipykernel)
   language: python
   name: python3
 language_info:
   name: python
+  nbconvert_exporter: python
   pygments_lexer: ipython3
 livereveal:
   auto_select: code
@@ -123,8 +124,9 @@ qui signifie de lancer, un délai de `time` secondes après le début du program
 ```{code-cell} ipython3
 class Scheduler:
 
-    def __init__(self, script):
-
+    def __init__(self, script, fut):
+        #objet future
+        self.fut = fut
         # on trie le script par ordre chronologique
         self.script = list(script)
         self.script.sort(key = lambda time_predef : time_predef[0])
@@ -147,7 +149,7 @@ class Scheduler:
         """
         # pour le mode avec clavier (pas fonctionnel dans le notebook)
         # on arme une callback sur stdin
-        asyncio.get_event_loop().add_reader(
+        asyncio.get_running_loop().add_reader(
             # il nous faut un file descriptor, pas un objet Python
             sys.stdin.fileno(),
             # la callback
@@ -217,7 +219,8 @@ class Scheduler:
         # Plus de processus en cours d'execution ET tous les processus executés
         if self.running == 0 and self.finished == self.to_be_run:
             print("no process left - bye")
-            asyncio.get_event_loop().stop()
+            # On set l'objet future à done pour quitter la boucle
+            self.fut.set_result("end")
         # sinon on retourne le code de retour
         return retcod
 
@@ -281,11 +284,13 @@ class Scheduler:
 ```{code-cell} ipython3
 class Clock:
 
-    def __init__(self):
+    def __init__(self, fut):
         self.clock_seconds = 0
+        self.fut = fut
 
     async def run(self):
-        while True:
+        # On regarde si l'objet future est done sinon Clock toune inndéfiniment.
+        while not self.fut.done():
             print(f"clock = {self.clock_seconds:04d}s")
             await asyncio.sleep(1)
             self.clock_seconds += 1
@@ -299,17 +304,18 @@ class Game:
     def __init__(self, script):
         self.script = script
 
-    def mainloop(self):
-        loop = asyncio.get_event_loop()
+    async def mainloop(self):
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
 
         # on met ensemble une clock et un scheduler
-        clock = Clock()
-        scheduler = Scheduler(self.script)
+        clock = Clock(fut)
+        scheduler = Scheduler(self.script, fut)
 
         # et on fait tourner le tout
         asyncio.ensure_future(clock.run())
         asyncio.ensure_future(scheduler.run())
-        loop.run_forever()
+        await fut
 ```
 
 Et maintenant je peux lancer une session simple ; pour ne pas être noyé par les sorties on va se contenter de lancer :
@@ -321,7 +327,7 @@ Et maintenant je peux lancer une session simple ; pour ne pas être noyé par l
 # nous allons juxtaposer 3 instances de players.py
 # et donc avoir 6 joueurs dans le jeu
 # La dernière instance se déroulera alors que les 2 premières sont terminées
-game = Game( [(0.5, 1), (1., 2), (6., 3])
+game = Game( [(0.5, 1), (1., 2), (6., 3)])
 ```
 
 ```{code-cell} ipython3
@@ -329,10 +335,8 @@ game = Game( [(0.5, 1), (1., 2), (6., 3])
 :tags: [raises-exception]
 
 # si vous êtes dans un notebook
-# cette exécution fonctionne, mais pour de sombres raisons
-# liées à des évolutions de IPython, le kernel va mourir
-# à la fin; ce n'est pas important..
-game.mainloop()
+
+await game.mainloop()
 ```
 
 ### Conclusion
@@ -351,7 +355,7 @@ Actuellement on peut trouver des bibliothèques au dessus de `asyncio` pour mani
 
 Si vous voulez exécuter ce code localement sur votre machine :
 
-Tout d'abord sachez que je n'ai pas du tout essayé ceci sur un OS Windows - et d'ailleurs ça m'intéresserait assez de savoir si ça fonctionne ou pas.
+Ne fonctionne pas sur OS Windows - Certaines fonctionnalités non implémentées.[Platform support python 3.10](https://docs.python.org/3/library/asyncio-platforms.html)
 
 Cela étant dit, il vous suffit alors de télécharger le présent notebook au format Python. Vous aurez aussi besoin :