R2F0ZS5pbyBBTUEgY29uIFZhbmFyIC0gTGEgcml2b2x1emlvbmFyaWEgYmxvY2tjaGFpbiBWYW5hciBvZmZyZSB1bmEgY2F0ZW5hIEwxIGEgYmFzc28gY29zdG8sIGFkIGFsdGEgdmVsb2NpdMOgIGUgYSBpbXBhdHRvIGFtYmllbnRhbGUgemVybyBwcm9nZXR0YXRhIHBlciBsJ2ludHJhdHRlbmltZW50byBlIGlsIGdyYW5kZSBwdWJibGl

<p><img src="https://gimg2.gateimg.com/image/article/17024489311.jpeg" alt=""><br><strong>Ora: 7 dicembre 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Ash Mohammed, CSO di Vanar nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://vanarchain.com/" rel="nofollow noopener noreferrer" target="_blank">https://vanarchain.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Vanarchain" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Vanarchain</a></strong><br><strong>Segui Vanar su <a href="https://t.me/vanarchain" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/Vanarchain" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17024491052.jpeg" alt=""><br><strong>Mohammed - CSO di Vanar</strong></p>
<h2 id="h2-QampA20da20Gateio456412"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Puoi20darci20una20breve20panoramica20di20Vanar20e20del20suo20percorso20nello20spazio20blockchain116277"><a name="Q1: Puoi darci una breve panoramica di Vanar e del suo percorso nello spazio blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi darci una breve panoramica di Vanar e del suo percorso nello spazio blockchain?</h3><p><strong>Mohammed</strong>: Vanar, inizialmente conosciuto come Virtua $TVK, è stato un pioniere nel settore delle blockchain dal 2018, concentrandosi su NFT e Metaverse. Siamo stati molto precoci nello spazio e abbiamo lavorato con partner straordinari. Nel corso di questo tempo abbiamo sviluppato prodotti straordinari, tra cui spazi metaversali, marketplace, rete di giochi, VR e XR e altro ancora!</p>
<p>Tuttavia, così tante persone stanno creando Metaversi - hanno bisogno di utenti.<br><img src="https://gimg2.gateimg.com/image/article/17024491273.jpeg" alt=""><br>Abbiamo capito di dover essere più di semplici utenti della tecnologia blockchain; dovevamo guidarne l’evoluzione e l’adozione. Per fare un vero impatto, abbiamo deciso di prendere in mano la situazione, passando da semplici partecipanti al mondo della blockchain a diventare uno dei suoi innovatori, con un profondo focus sugli utenti finali e gli adottanti, proprio come eravamo.</p>
<h3 id="h3-Q220Cosa20ha20spinto20la20transizione20di20Vanar20da20NFTMetaverse20a20un20focus20pi20ampio20sulla20blockchain616103"><a name="Q2: Cosa ha spinto la transizione di Vanar da NFT/Metaverse a un focus più ampio sulla blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cosa ha spinto la transizione di Vanar da NFT/Metaverse a un focus più ampio sulla blockchain?</h3><p><strong>Mohammed</strong>: La nostra transizione è stata motivata dalle difficoltà che le aziende mainstream affrontano con la tecnologia blockchain: comprenderla, gestire portafogli, gestire transazioni, far fronte ai prezzi del gas fluttuanti e gestire più marketplaces di terze parti. Abbiamo visto un’opportunità per semplificare questo processo e diventare un punto di riferimento per queste aziende. E loro lo adorano assolutamente. Questo cambiamento ci consente di offrire soluzioni blockchain snelle e facili da usare, rendendo la tecnologia accessibile e gestibile per i nostri partner.</p>
<h3 id="h3-Q320Puoi20approfondire20le20collaborazioni20di20Vanar20e20cosa20c20in20serbo20per20il20futuro20prossimo979536"><a name="Q3: Puoi approfondire le collaborazioni di Vanar e cosa c’è in serbo per il futuro prossimo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi approfondire le collaborazioni di Vanar e cosa c’è in serbo per il futuro prossimo?</h3><p><strong>Mohammed</strong>: Le partnership di Vanar sono una testimonianza del nostro approccio innovativo nel settore blockchain. Accanto ai nostri piani futuri, abbiamo avuto collaborazioni di successo con marchi rinomati come Paramount, Legendary, Shelby e Kevin Hart. La nostra partnership con Emirates Digital Wallet, di proprietà delle 16 banche più grandi degli Emirati, esemplifica il nostro impegno per l’innovazione finanziaria. Con Google Cloud, soprattutto dopo il nostro recente AMA con loro, stiamo lavorando per diventare la blockchain più efficiente dal punto di vista energetico, eseguendo i nostri nodi su energia rinnovabile.</p>
<p>Solo questo mese, stiamo portando in azienda uno studio di giochi con circa 1 miliardo di download tra i loro giochi e 100 milioni di utenti. Queste collaborazioni sono solo un’anteprima di come stiamo spingendo i limiti nello spazio blockchain.</p>
<h3 id="h3-Q420Potresti20parlare20del20team20dietro20Vanar20in20particolare20delle20figure20chiave20come20Doug20Dyer20Gary20Bracey20e20Jawad20Ashraf380152"><a name="Q4: Potresti parlare del team dietro Vanar, in particolare delle figure chiave come Doug Dyer, Gary Bracey e Jawad Ashraf?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Potresti parlare del team dietro Vanar, in particolare delle figure chiave come Doug Dyer, Gary Bracey e Jawad Ashraf?</h3><p><strong>Mohammed</strong>: Da Vanar, siamo orgogliosi di avere un team di leader del settore. Doug Dyer, un titan del gaming e dell’intrattenimento, porta con sé una grande quantità di conoscenze e connessioni. Il suo straordinario curriculum include ruoli fondamentali in giochi come “Age of Empires” di Microsoft e “Harry Potter” di Warner Bros., oltre ad essere uno dei membri fondatori del gigante del gaming THQ.</p>
<p>Gary Bracey, nostro co-fondatore e presidente, è un vero pioniere nell’industria dei videogiochi. Ha fatto la storia concedendo in licenza la prima IP di un film per un gioco con “RoboCop” presso Ocean Software. Le sue profonde connessioni e la sua comprensione dell’industria dei videogiochi sono preziose per la visione e la strategia di Vanar.</p>
<p>Jawad Ashraf, il nostro co-fondatore e CEO, è un noto imprenditore a Dubai, noto per la sua competenza tecnica e acume negli affari. Dopo aver portato a termine con successo l’uscita di numerose aziende tecnologiche con valutazioni superiori a $100M, Jawad porta un mix unico di conoscenze tecniche ed esperienza imprenditoriale per guidare il percorso di Vanar.</p>
<p>Insieme, questi leader, supportati dal nostro team di oltre 150 professionisti, guidano la missione di Vanar di innovare ed eccellere nello spazio della blockchain.</p>
<h3 id="h3-Q520In20cosa20si20differenzia20Vanar20dagli20altri20nuovi20blockchain20emersi20nel20202220e20nel20202320Cosa20lo20distingue168792"><a name="Q5: In cosa si differenzia Vanar dagli altri nuovi blockchain emersi nel 2022 e nel 2023? Cosa lo distingue?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: In cosa si differenzia Vanar dagli altri nuovi blockchain emersi nel 2022 e nel 2023? Cosa lo distingue?</h3><p><strong>Mohammed</strong>: Vanar si differenzia con un mix unico di funzionalità e l’utilità del nostro token, $VANRY. Il nostro focus sulle transazioni a basso costo e le alte prestazioni, unite alle DApps come servizio, si rivolgono perfettamente ai partner mainstream, favorendo un’adozione diffusa. L’utilità di $VANRY in questo ecosistema potenzia l’interazione degli utenti e incentiva la partecipazione, rendendolo più di una semplice valuta, ma un componente vitale della nostra infrastruttura blockchain.<br><img src="https://gimg2.gateimg.com/image/article/17024491404.jpeg" alt=""><br>Inoltre, la nostra enfasi sull’energia verde, in particolare attraverso la nostra collaborazione con Google Cloud, ci posiziona come leader nella tecnologia blockchain sostenibile. Questo approccio, insieme all’utilità strategica di $VANRY, ci differenzia, rendendo Vanar non solo una piattaforma blockchain, ma un ecosistema completo ecosostenibile per il futuro delle applicazioni decentralizzate e del commercio digitale.</p>
<h2 id="h2-QampA20in20diretta20dalla20comunit778926"><a name="Q&amp;A in diretta dalla comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A in diretta dalla comunità</h2><h3 id="h3-Q120Puoi20menzionare20alcuni20punti20salienti20del20team20dietro20il20tuo20progetto20Quali20sono20le20tue20esperienze20e20background20che20hanno20dato20vita20alla20piattaforma20e20garantito20la20sua20visione20e20lo20sviluppo20futuro20Conoscere20questo2020importante20per20guadagnare20la20fiducia20degli20investitori745798"><a name="Q1: Puoi menzionare alcuni punti salienti del team dietro il tuo progetto? Quali sono le tue esperienze e background che hanno dato vita alla piattaforma e garantito la sua visione e lo sviluppo futuro? Conoscere questo è importante per guadagnare la fiducia degli investitori." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi menzionare alcuni punti salienti del team dietro il tuo progetto? Quali sono le tue esperienze e background che hanno dato vita alla piattaforma e garantito la sua visione e lo sviluppo futuro? Conoscere questo è importante per guadagnare la fiducia degli investitori.</h3><p><strong>Mohammed</strong>: Ho parlato molto della squadra, ma la domanda è molto pertinente. Molti progetti promettono molto, ma non sono in grado di fornire, sia a causa delle forze di mercato, sia a causa della mancanza di esperienza. Abbiamo una squadra che ha pensato a più cicli tecnologici, dal PC di base, ai giochi, alle console, ai dispositivi mobili, poi alla web3, XR e AI. Comprendere la migliore ‘adeguatezza tecnologica’ è ciò che rende un marchio duraturo e sostenibile. Se continuiamo a parlare solo con un pubblico limitato, non possiamo entrare nel mainstream. Vogliamo che Vanar sia sinonimo di tecnologia web3, economie espandibili e gamefi come marchi riconosciuti come Microsoft o Google. Quindi è necessario avere persone con esperienza non solo per innovare, ma anche per navigare in mercati difficili. Siamo stati in giro per molto tempo attraverso inverni, orsi, ecc.! E siamo ancora qui e stiamo costruendo.</p>
<h3 id="h3-Q220In20che20modo20Vanar20affronta20le20sfide20affrontate20dalle20aziende20mainstream20con20la20tecnologia20blockchain20inclusi20problemi20legati20ai20portafogli20alle20transazioni20e20ai20prezzi20del20gas90765"><a name="Q2: In che modo Vanar affronta le sfide affrontate dalle aziende mainstream con la tecnologia blockchain, inclusi problemi legati ai portafogli, alle transazioni e ai prezzi del gas?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: In che modo Vanar affronta le sfide affrontate dalle aziende mainstream con la tecnologia blockchain, inclusi problemi legati ai portafogli, alle transazioni e ai prezzi del gas?</h3><p><strong>Mohammed</strong>: Le aziende mainstream affrontano molte sfide in questo settore, in primo luogo per capire quale sia l’opportunità stessa. Alcuni sono molto spaventati dalla criptovaluta, o non la comprendono, la associano a qualcosa di truffaldino. E le aziende che fanno attivazioni spesso non si rendono conto delle implicazioni e si trovano ad affrontare molte paure quando non fanno qualcosa nel modo giusto. C’è una cultura diversa nel web3. Dal punto di vista aziendale, affrontano anche problemi legati alla mancanza di controllo sul percorso dell’utente in modo che si adatti al loro marchio, partner tecnici che promettono molto ma non riescono a mantenere le promesse, preoccupazioni ambientali e ovviamente ciò che hai menzionato, cioè costi variabili del gas, commissioni di transazione elevate e confusione riguardo ai portafogli. Il nostro obiettivo è semplificare tutto ciò: abbiamo costi fissi, abbiamo strumenti per portafogli che consentono loro di gestire facilmente i propri utenti e le nostre dapps permettono loro di entrare nello spazio in un modo che funzioni per loro. Quindi potrebbe essere una intera verticale di prodotti nel web3, oppure potrebbe essere solo una singola attivazione o evento. Il nostro obiettivo è circondarli degli strumenti di cui hanno bisogno.</p>
<h3 id="h3-Q320Quali20piani20hai20per20il20futuro20di20Vanarchain20e20come20prevedi20di20far20crescere20lecosistema20dellinnovazione20e20della20collaborazione20tra20sviluppatori20utenti20e20aziende608271"><a name="Q3: Quali piani hai per il futuro di Vanarchain e come prevedi di far crescere l’ecosistema dell’innovazione e della collaborazione tra sviluppatori, utenti e aziende?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quali piani hai per il futuro di Vanarchain e come prevedi di far crescere l’ecosistema dell’innovazione e della collaborazione tra sviluppatori, utenti e aziende?</h3><p><strong>Mohammed</strong> Abbiamo GRANDI progetti. Iniziare con Google è stato intenzionale per segnalare quanto vogliamo andare lontano. In tutti gli ambiti dello sport, della musica, del gioco e del divertimento vogliamo fare un impatto, educare gli sviluppatori e far crescere l’ecosistema. Siamo anche in trattative con centri di incubazione nazionali in 3 paesi, per fare di Vanar la catena del paese dove gli sviluppatori locali possono costruire e sviluppare per creare un ecosistema sano in cui l’innovazione può accadere e affrontare anche i mercati locali. Ci sono opportunità in molti settori mainstream e enterprise, non limitati all’intrattenimento, ai giochi, ma anche all’identità, alla catena di approvvigionamento e molto altro ancora. Rilasceremo informazioni sul nostro programma di supporto agli sviluppatori, con un canale dedicato agli sviluppatori. L’educazione è così importante per questo. Vediamo tutti come un partner prezioso dove possiamo crescere insieme. Vanar è EVM quindi è facile da costruire e familiare anche per gli sviluppatori. Come dico sempre, si tratta di costruire una tecnologia che sia la ‘miglior soluzione’ anziché parlare solo di quanto sia grande la tecnologia per il gusto di farlo.</p>
<h3 id="h3-Q420Come20affronta20Vanar20Eco20i20punti20critici20chiave20per20i20marchi20nello20spazio20della20blockchain665015"><a name="Q4: Come affronta Vanar Eco i punti critici chiave per i marchi nello spazio della blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Come affronta Vanar Eco i punti critici chiave per i marchi nello spazio della blockchain?</h3><p><strong>Mohammed</strong>: Possiamo contare così tanti marchi che non volevano entrare nel <a href="/web3" target="_blank" class="blog_inner_link">web3</a> a causa delle loro preoccupazioni sull’impatto della tecnologia. Non solo questo, ma negli studi attuali, il 70% dei genz si aspetta che i marchi con cui lavorano siano responsabili nei confronti dell’ambiente.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Community Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>