diff --git a/src/content/reference/react/useTransition.md b/src/content/reference/react/useTransition.md
index 6533a201b..ada17a4e5 100644
--- a/src/content/reference/react/useTransition.md
+++ b/src/content/reference/react/useTransition.md
@@ -1,10 +1,17 @@
 ---
 title: useTransition
+translationStatus: ai-draft
 ---
 
+<Note>
+
+Questa pagina è stata tradotta automaticamente e supervisionata da un maintainer. Un'ulteriore revisione da parte della community sarebbe comunque utile. [Migliora questa traduzione](https://github.com/reactjs/it.react.dev/edit/main/src/content/reference/react/useTransition.md).
+
+</Note>
+
 <Intro>
 
-`useTransition` is a React Hook that lets you render a part of the UI in the background.
+`useTransition` è un Hook React che ti permette di renderizzare una parte dell'UI in background.
 
 ```js
 const [isPending, startTransition] = useTransition()
@@ -20,7 +27,7 @@ const [isPending, startTransition] = useTransition()
 
 ### `useTransition()` {/*usetransition*/}
 
-Call `useTransition` at the top level of your component to mark some state updates as Transitions.
+Chiama `useTransition` al top level del tuo componente per contrassegnare alcuni aggiornamenti di state come Transizioni.
 
 ```js
 import { useTransition } from 'react';
@@ -31,24 +38,24 @@ function TabContainer() {
 }
 ```
 
-[See more examples below.](#usage)
+[Vedi altri esempi sotto.](#usage)
 
 #### Parameters {/*parameters*/}
 
-`useTransition` does not take any parameters.
+`useTransition` non accetta parametri.
 
 #### Returns {/*returns*/}
 
-`useTransition` returns an array with exactly two items:
+`useTransition` restituisce un array con esattamente due elementi:
 
-1. The `isPending` flag that tells you whether there is a pending Transition.
-2. The [`startTransition` function](#starttransition) that lets you mark updates as a Transition.
+1. Il flag `isPending` che ti indica se c'è una Transizione in sospeso.
+2. La [funzione `startTransition`](#starttransition) che ti permette di contrassegnare gli aggiornamenti come Transizione.
 
 ---
 
 ### `startTransition(action)` {/*starttransition*/}
 
-The `startTransition` function returned by `useTransition` lets you mark an update as a Transition.
+La funzione `startTransition` restituita da `useTransition` ti permette di contrassegnare un aggiornamento come Transizione.
 
 ```js {6,8}
 function TabContainer() {
@@ -65,9 +72,9 @@ function TabContainer() {
 ```
 
 <Note>
-#### Functions called in `startTransition` are called "Actions". {/*functions-called-in-starttransition-are-called-actions*/}
+#### Le funzioni chiamate in `startTransition` si chiamano "Action". {/*functions-called-in-starttransition-are-called-actions*/}
 
-The function passed to `startTransition` is called an "Action". By convention, any callback called inside `startTransition` (such as a callback prop) should be named `action` or include the "Action" suffix:
+La funzione passata a `startTransition` si chiama "Action". Per convenzione, qualsiasi callback chiamata all'interno di `startTransition` (come una callback prop) dovrebbe chiamarsi `action` o includere il suffisso "Action":
 
 ```js {1,9}
 function SubmitButton({ submitAction }) {
@@ -95,35 +102,35 @@ function SubmitButton({ submitAction }) {
 
 #### Parameters {/*starttransition-parameters*/}
 
-* `action`: A function that updates some state by calling one or more [`set` functions](/reference/react/useState#setstate). React calls `action` immediately with no parameters and marks all state updates scheduled synchronously during the `action` function call as Transitions. Any async calls that are awaited in the `action` will be included in the Transition, but currently require wrapping any `set` functions after the `await` in an additional `startTransition` (see [Troubleshooting](#react-doesnt-treat-my-state-update-after-await-as-a-transition)). State updates marked as Transitions will be [non-blocking](#perform-non-blocking-updates-with-actions) and [will not display unwanted loading indicators](#preventing-unwanted-loading-indicators).
+* `action`: Una funzione che aggiorna lo state chiamando una o più [funzioni `set`](/reference/react/useState#setstate). React chiama `action` immediatamente senza parametri e contrassegna come Transizioni tutti gli aggiornamenti di state pianificati in modo sincrono durante la chiamata alla funzione `action`. Qualsiasi chiamata async attesa con `await` in `action` sarà inclusa nella Transizione, ma attualmente richiede di avvolgere qualsiasi funzione `set` dopo `await` in un ulteriore `startTransition` (vedi [Troubleshooting](#react-doesnt-treat-my-state-update-after-await-as-a-transition)). Gli aggiornamenti di state contrassegnati come Transizioni saranno [non bloccanti](#perform-non-blocking-updates-with-actions) e [non mostreranno indicatori di caricamento indesiderati](#preventing-unwanted-loading-indicators).
 
 #### Returns {/*starttransition-returns*/}
 
-`startTransition` does not return anything.
+`startTransition` non restituisce nulla.
 
 #### Caveats {/*starttransition-caveats*/}
 
-* `useTransition` is a Hook, so it can only be called inside components or custom Hooks. If you need to start a Transition somewhere else (for example, from a data library), call the standalone [`startTransition`](/reference/react/startTransition) instead.
+* `useTransition` è un Hook, quindi può essere chiamato solo all'interno di componenti o custom Hook. Se devi avviare una Transizione altrove (per esempio, da una libreria di dati), chiama invece la funzione standalone [`startTransition`](/reference/react/startTransition).
 
-* You can wrap an update into a Transition only if you have access to the `set` function of that state. If you want to start a Transition in response to some prop or a custom Hook value, try [`useDeferredValue`](/reference/react/useDeferredValue) instead.
+* Puoi avvolgere un aggiornamento in una Transizione solo se hai accesso alla funzione `set` di quello state. Se vuoi avviare una Transizione in risposta a una prop o a un valore di un custom Hook, prova [`useDeferredValue`](/reference/react/useDeferredValue).
 
-* The function you pass to `startTransition` is called immediately, marking all state updates that happen while it executes as Transitions. If you try to perform state updates in a `setTimeout`, for example, they won't be marked as Transitions.
+* La funzione che passi a `startTransition` viene chiamata immediatamente, contrassegnando come Transizioni tutti gli aggiornamenti di state che avvengono mentre viene eseguita. Se provi a eseguire aggiornamenti di state in un `setTimeout`, per esempio, non saranno contrassegnati come Transizioni.
 
-* You must wrap any state updates after any async requests in another `startTransition` to mark them as Transitions. This is a known limitation that we will fix in the future (see [Troubleshooting](#react-doesnt-treat-my-state-update-after-await-as-a-transition)).
+* Devi avvolgere qualsiasi aggiornamento di state dopo richieste async in un altro `startTransition` per contrassegnarli come Transizioni. Questa è una limitazione nota che correggeremo in futuro (vedi [Troubleshooting](#react-doesnt-treat-my-state-update-after-await-as-a-transition)).
 
-* The `startTransition` function has a stable identity, so you will often see it omitted from Effect dependencies, but including it will not cause the Effect to fire. If the linter lets you omit a dependency without errors, it is safe to do. [Learn more about removing Effect dependencies.](/learn/removing-effect-dependencies#move-dynamic-objects-and-functions-inside-your-effect)
+* La funzione `startTransition` ha un'identità stabile, quindi spesso la vedrai omessa dalle dipendenze degli Effetti, ma includerla non farà scattare l'Effetto. Se il linter ti permette di omettere una dipendenza senza errori, puoi farlo in sicurezza. [Scopri di più sulla rimozione delle dipendenze degli Effetti.](/learn/removing-effect-dependencies#move-dynamic-objects-and-functions-inside-your-effect)
 
-* A state update marked as a Transition will be interrupted by other state updates. For example, if you update a chart component inside a Transition, but then start typing into an input while the chart is in the middle of a re-render, React will restart the rendering work on the chart component after handling the input update.
+* Un aggiornamento di state contrassegnato come Transizione verrà interrotto da altri aggiornamenti di state. Per esempio, se aggiorni un componente grafico all'interno di una Transizione, ma poi inizi a digitare in un input mentre il grafico è nel mezzo di una ri-renderizzazione, React riavvierà il lavoro di renderizzazione sul componente grafico dopo aver gestito l'aggiornamento dell'input.
 
-* Transition updates can't be used to control text inputs.
+* Gli aggiornamenti Transizione non possono essere usati per controllare input di testo.
 
-* If there are multiple ongoing Transitions, React currently batches them together. This is a limitation that may be removed in a future release.
+* Se ci sono più Transizioni in corso, React attualmente le raggruppa insieme. Questa è una limitazione che potrebbe essere rimossa in una release futura.
 
 ## Usage {/*usage*/}
 
-### Perform non-blocking updates with Actions {/*perform-non-blocking-updates-with-actions*/}
+### Eseguire aggiornamenti non bloccanti con le Action {/*perform-non-blocking-updates-with-actions*/}
 
-Call `useTransition` at the top of your component to create Actions, and access the pending state:
+Chiama `useTransition` in cima al tuo componente per creare Action e accedere allo state pending:
 
 ```js [[1, 4, "isPending"], [2, 4, "startTransition"]]
 import {useState, useTransition} from 'react';
@@ -134,12 +141,12 @@ function CheckoutForm() {
 }
 ```
 
-`useTransition` returns an array with exactly two items:
+`useTransition` restituisce un array con esattamente due elementi:
 
-1. The <CodeStep step={1}>`isPending` flag</CodeStep> that tells you whether there is a pending Transition.
-2. The <CodeStep step={2}>`startTransition` function</CodeStep> that lets you create an Action.
+1. Il <CodeStep step={1}>flag `isPending`</CodeStep> che ti indica se c'è una Transizione in sospeso.
+2. La <CodeStep step={2}>funzione `startTransition`</CodeStep> che ti permette di creare un'Action.
 
-To start a Transition, pass a function to `startTransition` like this:
+Per avviare una Transizione, passa una funzione a `startTransition` così:
 
 ```js
 import {useState, useTransition} from 'react';
@@ -161,17 +168,17 @@ function CheckoutForm() {
 }
 ```
 
-The function passed to `startTransition` is called the "Action". You can update state and (optionally) perform side effects within an Action, and the work will be done in the background without blocking user interactions on the page. A Transition can include multiple Actions, and while a Transition is in progress, your UI stays responsive. For example, if the user clicks a tab but then changes their mind and clicks another tab, the second click will be immediately handled without waiting for the first update to finish.
+La funzione passata a `startTransition` si chiama "Action". Puoi aggiornare lo state e (opzionalmente) eseguire effetti collaterali all'interno di un'Action, e il lavoro verrà svolto in background senza bloccare le interazioni dell'utente sulla pagina. Una Transizione può includere più Action, e mentre una Transizione è in corso, la tua UI resta reattiva. Per esempio, se l'utente clicca una tab ma poi cambia idea e ne clicca un'altra, il secondo click verrà gestito immediatamente senza attendere il completamento del primo aggiornamento.
 
-To give the user feedback about in-progress Transitions, the `isPending` state switches to `true` at the first call to `startTransition`, and stays `true` until all Actions complete and the final state is shown to the user. Transitions ensure side effects in Actions to complete in order to [prevent unwanted loading indicators](#preventing-unwanted-loading-indicators), and you can provide immediate feedback while the Transition is in progress with `useOptimistic`.
+Per dare all'utente un feedback sulle Transizioni in corso, lo state `isPending` passa a `true` alla prima chiamata a `startTransition` e resta `true` finché tutte le Action non sono completate e lo state finale viene mostrato all'utente. Le Transizioni assicurano che gli effetti collaterali nelle Action si completino in ordine per [prevenire indicatori di caricamento indesiderati](#preventing-unwanted-loading-indicators), e puoi fornire un feedback immediato mentre la Transizione è in corso con `useOptimistic`.
 
-<Recipes titleText="The difference between Actions and regular event handling">
+<Recipes titleText="La differenza tra Action e gestione ordinaria degli eventi">
 
-#### Updating the quantity in an Action {/*updating-the-quantity-in-an-action*/}
+#### Aggiornare la quantità in un'Action {/*updating-the-quantity-in-an-action*/}
 
-In this example, the `updateQuantity` function simulates a request to the server to update the item's quantity in the cart. This function is *artificially slowed down* so that it takes at least a second to complete the request.
+In questo esempio, la funzione `updateQuantity` simula una richiesta al server per aggiornare la quantità dell'articolo nel carrello. Questa funzione è *artificialmente rallentata* in modo che impieghi almeno un secondo per completare la richiesta.
 
-Update the quantity multiple times quickly. Notice that the pending "Total" state is shown while any requests are in progress, and the "Total" updates only after the final request is complete. Because the update is in an Action, the "quantity" can continue to be updated while the request is in progress.
+Aggiorna la quantità più volte in rapida successione. Nota che lo state pending "Total" viene mostrato mentre le richieste sono in corso, e "Total" si aggiorna solo dopo che l'ultima richiesta è completata. Poiché l'aggiornamento è in un'Action, la "quantity" può continuare ad essere aggiornata mentre la richiesta è in corso.
 
 <Sandpack>
 
@@ -201,8 +208,8 @@ export default function App({}) {
   const [isPending, startTransition] = useTransition();
 
   const updateQuantityAction = async newQuantity => {
-    // To access the pending state of a transition,
-    // call startTransition again.
+    // Per accedere allo state pending di una Transizione,
+    // chiama di nuovo startTransition.
     startTransition(async () => {
       const savedQuantity = await updateQuantity(newQuantity);
       startTransition(() => {
@@ -227,7 +234,7 @@ import { startTransition } from "react";
 
 export default function Item({action}) {
   function handleChange(event) {
-    // To expose an action prop, await the callback in startTransition.
+    // Per esporre una prop action, fai await alla callback in startTransition.
     startTransition(async () => {
       await action(event.target.value);
     })
@@ -268,7 +275,7 @@ export default function Total({quantity, isPending}) {
 ```js src/api.js
 export async function updateQuantity(newQuantity) {
   return new Promise((resolve, reject) => {
-    // Simulate a slow network request.
+    // Simula una richiesta di rete lenta.
     setTimeout(() => {
       resolve(newQuantity);
     }, 2000);
@@ -305,22 +312,22 @@ export async function updateQuantity(newQuantity) {
 
 </Sandpack>
 
-This is a basic example to demonstrate how Actions work, but this example does not handle requests completing out of order. When updating the quantity multiple times, it's possible for the previous requests to finish after later requests causing the quantity to update out of order. This is a known limitation that we will fix in the future (see [Troubleshooting](#my-state-updates-in-transitions-are-out-of-order) below).
+Questo è un esempio base per dimostrare come funzionano le Action, ma non gestisce richieste che si completano fuori ordine. Quando aggiorni la quantità più volte, è possibile che le richieste precedenti finiscano dopo quelle successive, causando un aggiornamento della quantità fuori ordine. Questa è una limitazione nota che correggeremo in futuro (vedi [Troubleshooting](#my-state-updates-in-transitions-are-out-of-order) sotto).
 
-For common use cases, React provides built-in abstractions such as:
+Per casi d'uso comuni, React fornisce astrazioni integrate come:
 - [`useActionState`](/reference/react/useActionState)
-- [`<form>` actions](/reference/react-dom/components/form)
+- [action di `<form>`](/reference/react-dom/components/form)
 - [Server Functions](/reference/rsc/server-functions)
 
-These solutions handle request ordering for you. When using Transitions to build your own custom hooks or libraries that manage async state transitions, you have greater control over the request ordering, but you must handle it yourself.
+Queste soluzioni gestiscono l'ordinamento delle richieste per te. Quando usi le Transizioni per costruire i tuoi custom Hook o librerie che gestiscono transizioni async di state, hai un controllo maggiore sull'ordinamento delle richieste, ma devi gestirlo tu stesso.
 
 <Solution />
 
-#### Updating the quantity without an Action {/*updating-the-users-name-without-an-action*/}
+#### Aggiornare la quantità senza un'Action {/*updating-the-users-name-without-an-action*/}
 
-In this example, the `updateQuantity` function also simulates a request to the server to update the item's quantity in the cart. This function is *artificially slowed down* so that it takes at least a second to complete the request.
+In questo esempio, la funzione `updateQuantity` simula anch'essa una richiesta al server per aggiornare la quantità dell'articolo nel carrello. Questa funzione è *artificialmente rallentata* in modo che impieghi almeno un secondo per completare la richiesta.
 
-Update the quantity multiple times quickly. Notice that the pending "Total" state is shown while any requests is in progress, but the "Total" updates multiple times for each time the "quantity" was clicked:
+Aggiorna la quantità più volte in rapida successione. Nota che lo state pending "Total" viene mostrato mentre le richieste sono in corso, ma "Total" si aggiorna più volte per ogni volta che la "quantity" è stata modificata:
 
 <Sandpack>
 
@@ -350,7 +357,7 @@ export default function App({}) {
   const [isPending, setIsPending] = useState(false);
 
   const onUpdateQuantity = async newQuantity => {
-    // Manually set the isPending State.
+    // Imposta manualmente lo state isPending.
     setIsPending(true);
     const savedQuantity = await updateQuantity(newQuantity);
     setIsPending(false);
@@ -410,7 +417,7 @@ export default function Total({quantity, isPending}) {
 ```js src/api.js
 export async function updateQuantity(newQuantity) {
   return new Promise((resolve, reject) => {
-    // Simulate a slow network request.
+    // Simula una richiesta di rete lenta.
     setTimeout(() => {
       resolve(newQuantity);
     }, 2000);
@@ -447,7 +454,7 @@ export async function updateQuantity(newQuantity) {
 
 </Sandpack>
 
-A common solution to this problem is to prevent the user from making changes while the quantity is updating:
+Una soluzione comune a questo problema è impedire all'utente di apportare modifiche mentre la quantità si sta aggiornando:
 
 <Sandpack>
 
@@ -478,7 +485,7 @@ export default function App({}) {
 
   const onUpdateQuantity = async event => {
     const newQuantity = event.target.value;
-    // Manually set the isPending state.
+    // Imposta manualmente lo state isPending.
     setIsPending(true);
     const savedQuantity = await updateQuantity(newQuantity);
     setIsPending(false);
@@ -536,7 +543,7 @@ export default function Total({quantity, isPending}) {
 ```js src/api.js
 export async function updateQuantity(newQuantity) {
   return new Promise((resolve, reject) => {
-    // Simulate a slow network request.
+    // Simula una richiesta di rete lenta.
     setTimeout(() => {
       resolve(newQuantity);
     }, 2000);
@@ -573,7 +580,7 @@ export async function updateQuantity(newQuantity) {
 
 </Sandpack>
 
-This solution makes the app feel slow, because the user must wait each time they update the quantity. It's possible to add more complex handling manually to allow the user to interact with the UI while the quantity is updating, but Actions handle this case with a straight-forward built-in API.
+Questa soluzione fa sembrare l'app lenta, perché l'utente deve attendere ogni volta che aggiorna la quantità. È possibile aggiungere manualmente una gestione più complessa per permettere all'utente di interagire con l'UI mentre la quantità si aggiorna, ma le Action gestiscono questo caso con un'API integrata semplice.
 
 <Solution />
 
@@ -581,11 +588,11 @@ This solution makes the app feel slow, because the user must wait each time they
 
 ---
 
-### Exposing `action` prop from components {/*exposing-action-props-from-components*/}
+### Esporre la prop `action` dai componenti {/*exposing-action-props-from-components*/}
 
-You can expose an `action` prop from a component to allow a parent to call an Action.
+Puoi esporre una prop `action` da un componente per permettere a un genitore di chiamare un'Action.
 
-For example, this `TabButton` component wraps its `onClick` logic in an `action` prop:
+Per esempio, questo componente `TabButton` avvolge la sua logica `onClick` in una prop `action`:
 
 ```js {8-12}
 export default function TabButton({ action, children, isActive }) {
@@ -596,8 +603,8 @@ export default function TabButton({ action, children, isActive }) {
   return (
     <button onClick={() => {
       startTransition(async () => {
-        // await the action that's passed in.
-        // This allows it to be either sync or async.
+        // await all'action passata.
+        // Questo permette che sia sincrona o asincrona.
         await action();
       });
     }}>
@@ -607,7 +614,7 @@ export default function TabButton({ action, children, isActive }) {
 }
 ```
 
-Because the parent component updates its state inside the `action`, that state update gets marked as a Transition. This means you can click on "Posts" and then immediately click "Contact" and it does not block user interactions:
+Poiché il componente genitore aggiorna il suo state all'interno di `action`, quell'aggiornamento di state viene contrassegnato come Transizione. Questo significa che puoi cliccare su "Posts" e poi cliccare immediatamente su "Contact" senza bloccare le interazioni dell'utente:
 
 <Sandpack>
 
@@ -663,8 +670,8 @@ export default function TabButton({ action, children, isActive }) {
   return (
     <button onClick={async () => {
       startTransition(async () => {
-        // await the action that's passed in.
-        // This allows it to be either sync or async.
+        // await all'action passata.
+        // Questo permette che sia sincrona o asincrona.
         await action();
       });
     }}>
@@ -686,7 +693,7 @@ export default function AboutTab() {
 import { memo } from 'react';
 
 const PostsTab = memo(function PostsTab() {
-  // Log once. The actual slowdown is inside SlowPost.
+  // Log una volta. Il rallentamento effettivo è dentro SlowPost.
   console.log('[ARTIFICIALLY SLOW] Rendering 500 <SlowPost />');
 
   let items = [];
@@ -703,7 +710,7 @@ const PostsTab = memo(function PostsTab() {
 function SlowPost({ index }) {
   let startTime = performance.now();
   while (performance.now() - startTime < 1) {
-    // Do nothing for 1 ms per item to emulate extremely slow code
+    // Non fare nulla per 1 ms per elemento per emulare codice estremamente lento
   }
 
   return (
@@ -721,7 +728,7 @@ export default function ContactTab() {
   return (
     <>
       <p>
-        You can find me online here:
+        Puoi trovarmi online qui:
       </p>
       <ul>
         <li>admin@mysite.com</li>
@@ -746,17 +753,17 @@ b { display: inline-block; margin-right: 10px; }
 
 <Note>
 
-When exposing an `action` prop from a component, you should `await` it inside the transition.
+Quando esponi una prop `action` da un componente, dovresti fare `await` al suo interno nella Transizione.
 
-This allows the `action` callback to be either synchronous or asynchronous without requiring an additional `startTransition` to wrap the `await` in the action.
+Questo permette alla callback `action` di essere sincrona o asincrona senza richiedere un ulteriore `startTransition` per avvolgere `await` nell'action.
 
 </Note>
 
 ---
 
-### Displaying a pending visual state {/*displaying-a-pending-visual-state*/}
+### Mostrare uno state visivo pending {/*displaying-a-pending-visual-state*/}
 
-You can use the `isPending` boolean value returned by `useTransition` to indicate to the user that a Transition is in progress. For example, the tab button can have a special "pending" visual state:
+Puoi usare il valore booleano `isPending` restituito da `useTransition` per indicare all'utente che una Transizione è in corso. Per esempio, il pulsante tab può avere uno state visivo speciale "pending":
 
 ```js {4-6}
 function TabButton({ action, children, isActive }) {
@@ -768,7 +775,7 @@ function TabButton({ action, children, isActive }) {
   // ...
 ```
 
-Notice how clicking "Posts" now feels more responsive because the tab button itself updates right away:
+Nota come cliccare su "Posts" ora sembri più reattivo perché il pulsante tab stesso si aggiorna subito:
 
 <Sandpack>
 
@@ -845,7 +852,7 @@ export default function AboutTab() {
 import { memo } from 'react';
 
 const PostsTab = memo(function PostsTab() {
-  // Log once. The actual slowdown is inside SlowPost.
+  // Log una volta. Il rallentamento effettivo è dentro SlowPost.
   console.log('[ARTIFICIALLY SLOW] Rendering 500 <SlowPost />');
 
   let items = [];
@@ -862,7 +869,7 @@ const PostsTab = memo(function PostsTab() {
 function SlowPost({ index }) {
   let startTime = performance.now();
   while (performance.now() - startTime < 1) {
-    // Do nothing for 1 ms per item to emulate extremely slow code
+    // Non fare nulla per 1 ms per elemento per emulare codice estremamente lento
   }
 
   return (
@@ -880,7 +887,7 @@ export default function ContactTab() {
   return (
     <>
       <p>
-        You can find me online here:
+        Puoi trovarmi online qui:
       </p>
       <ul>
         <li>admin@mysite.com</li>
@@ -905,9 +912,9 @@ b { display: inline-block; margin-right: 10px; }
 
 ---
 
-### Preventing unwanted loading indicators {/*preventing-unwanted-loading-indicators*/}
+### Prevenire indicatori di caricamento indesiderati {/*preventing-unwanted-loading-indicators*/}
 
-In this example, the `PostsTab` component fetches some data using [use](/reference/react/use). When you click the "Posts" tab, the `PostsTab` component *suspends*, causing the closest loading fallback to appear:
+In questo esempio, il componente `PostsTab` recupera dei dati usando [use](/reference/react/use). Quando clicchi la tab "Posts", il componente `PostsTab` *sospende*, causando la comparsa del fallback di caricamento più vicino:
 
 <Sandpack>
 
@@ -1003,7 +1010,7 @@ export default function ContactTab() {
   return (
     <>
       <p>
-        You can find me online here:
+        Puoi trovarmi online qui:
       </p>
       <ul>
         <li>admin@mysite.com</li>
@@ -1016,9 +1023,9 @@ export default function ContactTab() {
 
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: il modo in cui faresti il data fetching dipende
+// dal framework che usi insieme a Suspense.
+// Normalmente, la logica di caching sarebbe dentro un framework.
 
 let cache = new Map();
 
@@ -1038,7 +1045,7 @@ async function getData(url) {
 }
 
 async function getPosts() {
-  // Add a fake delay to make waiting noticeable.
+  // Aggiungi un ritardo fittizio per far notare l'attesa.
   await new Promise(resolve => {
     setTimeout(resolve, 1000);
   });
@@ -1061,9 +1068,9 @@ b { display: inline-block; margin-right: 10px; }
 
 </Sandpack>
 
-Hiding the entire tab container to show a loading indicator leads to a jarring user experience. If you add `useTransition` to `TabButton`, you can instead display the pending state in the tab button instead.
+Nascondere l'intero contenitore delle tab per mostrare un indicatore di caricamento produce un'esperienza utente brusca. Se aggiungi `useTransition` a `TabButton`, puoi invece mostrare lo state pending nel pulsante tab.
 
-Notice that clicking "Posts" no longer replaces the entire tab container with a spinner:
+Nota che cliccare su "Posts" non sostituisce più l'intero contenitore delle tab con uno spinner:
 
 <Sandpack>
 
@@ -1167,7 +1174,7 @@ export default function ContactTab() {
   return (
     <>
       <p>
-        You can find me online here:
+        Puoi trovarmi online qui:
       </p>
       <ul>
         <li>admin@mysite.com</li>
@@ -1180,9 +1187,9 @@ export default function ContactTab() {
 
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: il modo in cui faresti il data fetching dipende
+// dal framework che usi insieme a Suspense.
+// Normalmente, la logica di caching sarebbe dentro un framework.
 
 let cache = new Map();
 
@@ -1202,7 +1209,7 @@ async function getData(url) {
 }
 
 async function getPosts() {
-  // Add a fake delay to make waiting noticeable.
+  // Aggiungi un ritardo fittizio per far notare l'attesa.
   await new Promise(resolve => {
     setTimeout(resolve, 1000);
   });
@@ -1225,19 +1232,19 @@ b { display: inline-block; margin-right: 10px; }
 
 </Sandpack>
 
-[Read more about using Transitions with Suspense.](/reference/react/Suspense#preventing-already-revealed-content-from-hiding)
+[Leggi di più sull'uso delle Transizioni con Suspense.](/reference/react/Suspense#preventing-already-revealed-content-from-hiding)
 
 <Note>
 
-Transitions only "wait" long enough to avoid hiding *already revealed* content (like the tab container). If the Posts tab had a [nested `<Suspense>` boundary,](/reference/react/Suspense#revealing-nested-content-as-it-loads) the Transition would not "wait" for it.
+Le Transizioni "attendono" solo abbastanza a lungo per evitare di nascondere contenuto *già rivelato* (come il contenitore delle tab). Se la tab Posts avesse un [boundary `<Suspense>` annidato,](/reference/react/Suspense#revealing-nested-content-as-it-loads) la Transizione non "attenderebbe" per esso.
 
 </Note>
 
 ---
 
-### Building a Suspense-enabled router {/*building-a-suspense-enabled-router*/}
+### Costruire un router abilitato a Suspense {/*building-a-suspense-enabled-router*/}
 
-If you're building a React framework or a router, we recommend marking page navigations as Transitions.
+Se stai costruendo un framework React o un router, ti consigliamo di contrassegnare le navigazioni di pagina come Transizioni.
 
 ```js {3,6,8}
 function Router() {
@@ -1252,13 +1259,13 @@ function Router() {
   // ...
 ```
 
-This is recommended for three reasons:
+Questo è consigliato per tre motivi:
 
-- [Transitions are interruptible,](#perform-non-blocking-updates-with-actions) which lets the user click away without waiting for the re-render to complete.
-- [Transitions prevent unwanted loading indicators,](#preventing-unwanted-loading-indicators) which lets the user avoid jarring jumps on navigation.
-- [Transitions wait for all pending actions](#perform-non-blocking-updates-with-actions) which lets the user wait for side effects to complete before the new page is shown.
+- [Le Transizioni sono interrompibili,](#perform-non-blocking-updates-with-actions) il che permette all'utente di cliccare altrove senza attendere il completamento della ri-renderizzazione.
+- [Le Transizioni prevengono indicatori di caricamento indesiderati,](#preventing-unwanted-loading-indicators) il che permette all'utente di evitare salti bruschi durante la navigazione.
+- [Le Transizioni attendono che tutte le Action in sospeso si completino](#perform-non-blocking-updates-with-actions), il che permette all'utente di attendere il completamento degli effetti collaterali prima che la nuova pagina venga mostrata.
 
-Here is a simplified router example using Transitions for navigations.
+Ecco un esempio semplificato di router che usa le Transizioni per le navigazioni.
 
 <Sandpack>
 
@@ -1414,9 +1421,9 @@ export default function Panel({ children }) {
 ```
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: il modo in cui faresti il data fetching dipende
+// dal framework che usi insieme a Suspense.
+// Normalmente, la logica di caching sarebbe dentro un framework.
 
 let cache = new Map();
 
@@ -1438,7 +1445,7 @@ async function getData(url) {
 }
 
 async function getBio() {
-  // Add a fake delay to make waiting noticeable.
+  // Aggiungi un ritardo fittizio per far notare l'attesa.
   await new Promise(resolve => {
     setTimeout(resolve, 500);
   });
@@ -1450,7 +1457,7 @@ async function getBio() {
 }
 
 async function getAlbums() {
-  // Add a fake delay to make waiting noticeable.
+  // Aggiungi un ritardo fittizio per far notare l'attesa.
   await new Promise(resolve => {
     setTimeout(resolve, 3000);
   });
@@ -1559,15 +1566,15 @@ main {
 
 <Note>
 
-[Suspense-enabled](/reference/react/Suspense) routers are expected to wrap the navigation updates into Transitions by default.
+I router [abilitati a Suspense](/reference/react/Suspense) dovrebbero avvolgere gli aggiornamenti di navigazione in Transizioni per impostazione predefinita.
 
 </Note>
 
 ---
 
-### Displaying an error to users with an error boundary {/*displaying-an-error-to-users-with-error-boundary*/}
+### Mostrare un errore agli utenti con un error boundary {/*displaying-an-error-to-users-with-error-boundary*/}
 
-If a function passed to `startTransition` throws an error or returns a rejected Promise, you can display an error to your user with an [error boundary](/reference/react/Component#catching-rendering-errors-with-an-error-boundary). To use an error boundary, wrap the component where you are calling the `useTransition` in an error boundary. Once the function passed to `startTransition` errors, the fallback for the error boundary will be displayed.
+Se una funzione passata a `startTransition` lancia un errore o restituisce una Promise rifiutata, puoi mostrare un errore al tuo utente con un [error boundary](/reference/react/Component#catching-rendering-errors-with-an-error-boundary). Per usare un error boundary, avvolgi il componente in cui chiami `useTransition` in un error boundary. Una volta che la funzione passata a `startTransition` genera un errore, verrà mostrato il fallback dell'error boundary.
 
 <Sandpack>
 
@@ -1584,7 +1591,7 @@ export function AddCommentContainer() {
 }
 
 function addComment(comment) {
-  // For demonstration purposes to show Error Boundary
+  // A scopo dimostrativo per mostrare l'Error Boundary
   if (comment == null) {
     throw new Error("Example Error: An error thrown to trigger error boundary");
   }
@@ -1598,8 +1605,8 @@ function AddCommentButton() {
       disabled={pending}
       onClick={() => {
         startTransition(() => {
-          // Intentionally not passing a comment
-          // so error gets thrown
+          // Intenzionalmente non passa un commento
+          // così viene lanciato un errore
           addComment();
         });
       }}
@@ -1649,15 +1656,15 @@ root.render(
 
 ## Troubleshooting {/*troubleshooting*/}
 
-### Updating an input in a Transition doesn't work {/*updating-an-input-in-a-transition-doesnt-work*/}
+### Aggiornare un input in una Transizione non funziona {/*updating-an-input-in-a-transition-doesnt-work*/}
 
-You can't use a Transition for a state variable that controls an input:
+Non puoi usare una Transizione per una variabile di state che controlla un input:
 
 ```js {4,10}
 const [text, setText] = useState('');
 // ...
 function handleChange(e) {
-  // ❌ Can't use Transitions for controlled input state
+  // ❌ Non puoi usare Transizioni per lo state di un input controllato
   startTransition(() => {
     setText(e.target.value);
   });
@@ -1666,41 +1673,41 @@ function handleChange(e) {
 return <input value={text} onChange={handleChange} />;
 ```
 
-This is because Transitions are non-blocking, but updating an input in response to the change event should happen synchronously. If you want to run a Transition in response to typing, you have two options:
+Questo perché le Transizioni sono non bloccanti, ma aggiornare un input in risposta all'evento change dovrebbe avvenire in modo sincrono. Se vuoi eseguire una Transizione in risposta alla digitazione, hai due opzioni:
 
-1. You can declare two separate state variables: one for the input state (which always updates synchronously), and one that you will update in a Transition. This lets you control the input using the synchronous state, and pass the Transition state variable (which will "lag behind" the input) to the rest of your rendering logic.
-2. Alternatively, you can have one state variable, and add [`useDeferredValue`](/reference/react/useDeferredValue) which will "lag behind" the real value. It will trigger non-blocking re-renders to "catch up" with the new value automatically.
+1. Puoi dichiarare due variabili di state separate: una per lo state dell'input (che si aggiorna sempre in modo sincrono) e una che aggiornerai in una Transizione. Questo ti permette di controllare l'input usando lo state sincrono e passare la variabile di state Transizione (che resterà "indietro" rispetto all'input) al resto della tua logica di renderizzazione.
+2. In alternativa, puoi avere una variabile di state e aggiungere [`useDeferredValue`](/reference/react/useDeferredValue) che resterà "indietro" rispetto al valore reale. Attiverà ri-renderizzazioni non bloccanti per "recuperare" automaticamente il nuovo valore.
 
 ---
 
-### React doesn't treat my state update as a Transition {/*react-doesnt-treat-my-state-update-as-a-transition*/}
+### React non tratta il mio aggiornamento di state come Transizione {/*react-doesnt-treat-my-state-update-as-a-transition*/}
 
-When you wrap a state update in a Transition, make sure that it happens *during* the `startTransition` call:
+Quando avvolgi un aggiornamento di state in una Transizione, assicurati che avvenga *durante* la chiamata a `startTransition`:
 
 ```js
 startTransition(() => {
-  // ✅ Setting state *during* startTransition call
+  // ✅ Impostare lo state *durante* la chiamata a startTransition
   setPage('/about');
 });
 ```
 
-The function you pass to `startTransition` must be synchronous. You can't mark an update as a Transition like this:
+La funzione che passi a `startTransition` deve essere sincrona. Non puoi contrassegnare un aggiornamento come Transizione così:
 
 ```js
 startTransition(() => {
-  // ❌ Setting state *after* startTransition call
+  // ❌ Impostare lo state *dopo* la chiamata a startTransition
   setTimeout(() => {
     setPage('/about');
   }, 1000);
 });
 ```
 
-Instead, you could do this:
+Invece, potresti fare così:
 
 ```js
 setTimeout(() => {
   startTransition(() => {
-    // ✅ Setting state *during* startTransition call
+    // ✅ Impostare lo state *durante* la chiamata a startTransition
     setPage('/about');
   });
 }, 1000);
@@ -1708,47 +1715,43 @@ setTimeout(() => {
 
 ---
 
-### React doesn't treat my state update after `await` as a Transition {/*react-doesnt-treat-my-state-update-after-await-as-a-transition*/}
+### React non tratta il mio aggiornamento di state dopo `await` come Transizione {/*react-doesnt-treat-my-state-update-after-await-as-a-transition*/}
 
-When you use `await` inside a `startTransition` function, the state updates that happen after the `await` are not marked as Transitions. You must wrap state updates after each `await` in a `startTransition` call:
+Quando usi `await` all'interno di una funzione `startTransition`, gli aggiornamenti di state che avvengono dopo `await` non sono contrassegnati come Transizioni. Devi avvolgere gli aggiornamenti di state dopo ogni `await` in una chiamata a `startTransition`:
 
 ```js
 startTransition(async () => {
   await someAsyncFunction();
-  // ❌ Not using startTransition after await
+  // ❌ Non usare startTransition dopo await
   setPage('/about');
 });
 ```
 
-However, this works instead:
+Tuttavia, funziona così:
 
 ```js
 startTransition(async () => {
   await someAsyncFunction();
-  // ✅ Using startTransition *after* await
+  // ✅ Usare startTransition *dopo* await
   startTransition(() => {
     setPage('/about');
   });
 });
 ```
 
-This is a JavaScript limitation due to React losing the scope of the async context. In the future, when [AsyncContext](https://github.com/tc39/proposal-async-context) is available, this limitation will be removed.
+Questa è una limitazione di JavaScript dovuta al fatto che React perde lo scope del contesto async. In futuro, quando [AsyncContext](https://github.com/tc39/proposal-async-context) sarà disponibile, questa limitazione verrà rimossa.
 
 ---
 
-### I want to call `useTransition` from outside a component {/*i-want-to-call-usetransition-from-outside-a-component*/}
+### Voglio chiamare `useTransition` dall'esterno di un componente {/*i-want-to-call-usetransition-from-outside-a-component*/}
 
-You can't call `useTransition` outside a component because it's a Hook. In this
-case, the standalone [`startTransition`](/reference/react/startTransition)
-function can mark state updates as Transitions. It does not provide the
-`isPending` flag. Because the standalone function is not associated with a
-component, an Error Boundary cannot handle errors from its Transition.
+Non puoi chiamare `useTransition` fuori da un componente perché è un Hook. In questo caso, la funzione standalone [`startTransition`](/reference/react/startTransition) può contrassegnare gli aggiornamenti di state come Transizioni. Non fornisce il flag `isPending`. Poiché la funzione standalone non è associata a un componente, un Error Boundary non può gestire errori dalla sua Transizione.
 
 ---
 
-### The function I pass to `startTransition` executes immediately {/*the-function-i-pass-to-starttransition-executes-immediately*/}
+### La funzione che passo a `startTransition` viene eseguita immediatamente {/*the-function-i-pass-to-starttransition-executes-immediately*/}
 
-If you run this code, it will print 1, 2, 3:
+Se esegui questo codice, stamperà 1, 2, 3:
 
 ```js {1,3,6}
 console.log(1);
@@ -1759,10 +1762,10 @@ startTransition(() => {
 console.log(3);
 ```
 
-**It is expected to print 1, 2, 3.** The function you pass to `startTransition` does not get delayed. Unlike with the browser `setTimeout`, it does not run the callback later. React executes your function immediately, but any state updates scheduled *while it is running* are marked as Transitions. You can imagine that it works like this:
+**È previsto che stampi 1, 2, 3.** La funzione che passi a `startTransition` non viene ritardata. A differenza del `setTimeout` del browser, non esegue la callback in seguito. React esegue la tua funzione immediatamente, ma qualsiasi aggiornamento di state pianificato *mentre è in esecuzione* viene contrassegnato come Transizione. Puoi immaginare che funzioni così:
 
 ```js
-// A simplified version of how React works
+// Una versione semplificata di come funziona React
 
 let isInsideTransition = false;
 
@@ -1774,20 +1777,20 @@ function startTransition(scope) {
 
 function setState() {
   if (isInsideTransition) {
-    // ... schedule a Transition state update ...
+    // ... pianifica un aggiornamento di state Transizione ...
   } else {
-    // ... schedule an urgent state update ...
+    // ... pianifica un aggiornamento di state urgente ...
   }
 }
 ```
 
-### My state updates in Transitions are out of order {/*my-state-updates-in-transitions-are-out-of-order*/}
+### I miei aggiornamenti di state nelle Transizioni sono fuori ordine {/*my-state-updates-in-transitions-are-out-of-order*/}
 
-If you `await` inside `startTransition`, you might see the updates happen out of order.
+Se fai `await` all'interno di `startTransition`, potresti vedere gli aggiornamenti avvenire fuori ordine.
 
-In this example, the `updateQuantity` function simulates a request to the server to update the item's quantity in the cart. This function *artificially returns every other request after the previous* to simulate race conditions for network requests.
+In questo esempio, la funzione `updateQuantity` simula una richiesta al server per aggiornare la quantità dell'articolo nel carrello. Questa funzione *artificialmente restituisce ogni altra richiesta dopo la precedente* per simulare race condition nelle richieste di rete.
 
-Try updating the quantity once, then update it quickly multiple times. You might see the incorrect total:
+Prova ad aggiornare la quantità una volta, poi aggiornarla rapidamente più volte. Potresti vedere il totale errato:
 
 <Sandpack>
 
@@ -1815,14 +1818,14 @@ import Total from "./Total";
 export default function App({}) {
   const [quantity, setQuantity] = useState(1);
   const [isPending, startTransition] = useTransition();
-  // Store the actual quantity in separate state to show the mismatch.
+  // Memorizza la quantità effettiva in uno state separato per mostrare la discrepanza.
   const [clientQuantity, setClientQuantity] = useState(1);
 
   const updateQuantityAction = newQuantity => {
     setClientQuantity(newQuantity);
 
-    // Access the pending state of the transition,
-    // by wrapping in startTransition again.
+    // Accedi allo state pending della Transizione
+    // avvolgendo di nuovo in startTransition.
     startTransition(async () => {
       const savedQuantity = await updateQuantity(newQuantity);
       startTransition(() => {
@@ -1848,7 +1851,7 @@ import {startTransition} from 'react';
 
 export default function Item({action}) {
   function handleChange(e) {
-    // Update the quantity in an Action.
+    // Aggiorna la quantità in un'Action.
     startTransition(async () => {
       await action(e.target.value);
     });
@@ -1904,7 +1907,7 @@ export async function updateQuantity(newName) {
       setTimeout(() => {
         firstRequest = true;
         resolve(newName);
-        // Simulate every other request being slower
+        // Simula ogni altra richiesta più lenta
       }, 1000);
     } else {
       setTimeout(() => {
@@ -1955,12 +1958,12 @@ export async function updateQuantity(newName) {
 </Sandpack>
 
 
-When clicking multiple times, it's possible for previous requests to finish after later requests. When this happens, React currently has no way to know the intended order. This is because the updates are scheduled asynchronously, and React loses context of the order across the async boundary.
+Quando clicchi più volte, è possibile che le richieste precedenti finiscano dopo quelle successive. Quando succede, React attualmente non ha modo di conoscere l'ordine previsto. Questo perché gli aggiornamenti sono pianificati in modo asincrono e React perde il contesto dell'ordine attraverso il confine async.
 
-This is expected, because Actions within a Transition do not guarantee execution order. For common use cases, React provides higher-level abstractions like [`useActionState`](/reference/react/useActionState) and [`<form>` actions](/reference/react-dom/components/form) that handle ordering for you. For advanced use cases, you'll need to implement your own queuing and abort logic to handle this.
+Questo è previsto, perché le Action all'interno di una Transizione non garantiscono l'ordine di esecuzione. Per casi d'uso comuni, React fornisce astrazioni di livello superiore come [`useActionState`](/reference/react/useActionState) e [action di `<form>`](/reference/react-dom/components/form) che gestiscono l'ordinamento per te. Per casi d'uso avanzati, dovrai implementare la tua logica di accodamento e abort per gestirlo.
 
 
-Example of `useActionState` handling execution order:
+Esempio di `useActionState` che gestisce l'ordine di esecuzione:
 
 <Sandpack>
 
@@ -1986,13 +1989,13 @@ import Item from "./Item";
 import Total from "./Total";
 
 export default function App({}) {
-  // Store the actual quantity in separate state to show the mismatch.
+  // Memorizza la quantità effettiva in uno state separato per mostrare la discrepanza.
   const [clientQuantity, setClientQuantity] = useState(1);
   const [quantity, updateQuantityAction, isPending] = useActionState(
     async (prevState, payload) => {
       setClientQuantity(payload);
       const savedQuantity = await updateQuantity(payload);
-      return savedQuantity; // Return the new quantity to update the state
+      return savedQuantity; // Restituisce la nuova quantità per aggiornare lo state
     },
     1 // Initial quantity
   );
@@ -2014,7 +2017,7 @@ import {startTransition} from 'react';
 
 export default function Item({action}) {
   function handleChange(e) {
-    // Update the quantity in an Action.
+    // Aggiorna la quantità in un'Action.
     startTransition(() => {
       action(e.target.value);
     });
@@ -2070,7 +2073,7 @@ export async function updateQuantity(newName) {
       setTimeout(() => {
         firstRequest = true;
         resolve(newName);
-        // Simulate every other request being slower
+        // Simula ogni altra richiesta più lenta
       }, 1000);
     } else {
       setTimeout(() => {