R2F0ZS5pbyBBTUEgbWV0IFZhbmFyLURlIEJhYW5icmVrZW5kZSBCbG9ja2NoYWluIFZhbmFyIEJpZWR0IGVlbiBLb29sc3RvZm5ldXRyYWxlLCBIb2dlLXNuZWxoZWlkICYgTGFnZS1rb3N0ZW4gTDEta2V0ZW4gT250d29ycGVuIHZvb3IgRW50ZXJ0YWlubWVudCBlbiBNYWluc3RyZWFt

<p><img src="https://gimg2.gateimg.com/image/article/17024489311.jpeg" alt=""><br><strong>Tijd: 7 december 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Ash Mohammed, CSO van Vanar in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <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>Volg Vanar op <a href="https://t.me/vanarchain" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/Vanarchain" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17024491052.jpeg" alt=""><br><strong>Mohammed - CSO van Vanar</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio627634"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20ons20een20korte20introductie20geven20van20Vanar20en20zijn20reis20in20de20blockchainruimte361039"><a name="Q1: Kun je ons een korte introductie geven van Vanar en zijn reis in de blockchain-ruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons een korte introductie geven van Vanar en zijn reis in de blockchain-ruimte?</h3><p><strong>Mohammed</strong>: Vanar, oorspronkelijk bekend als Virtua $TVK, is sinds 2018 pionier in de blockchain-ruimte, met de nadruk op NFT’s en de Metaverse. We waren super vroeg in de ruimte en werkten met geweldige partners. In deze tijd hebben we geweldige producten gebouwd, waaronder metaverse-ruimtes, marktplaats, games-netwerk, VR en XR en meer!</p>
<p>Maar zoveel mensen maken Metaverses - ze hebben gebruikers nodig.<br><img src="https://gimg2.gateimg.com/image/article/17024491273.jpeg" alt=""><br>We realiseerden ons dat we meer moesten zijn dan alleen gebruikers van blockchaintechnologie; we moesten de leiding nemen in de evolutie en adoptie ervan. Om een echte impact te maken, besloten we zelf de touwtjes in handen te nemen. We veranderden van een deelnemer in de blockchainwereld naar een van de vernieuwers ervan, met een diepe focus op de eindgebruikers en adoptanten, net zoals wij.</p>
<h3 id="h3-Q220Wat20heeft20Vanar20ertoe20gebracht20om20de20focus20te20verleggen20van20NFTMetaverse20naar20een20breder20blockchainaandachtsgebied721436"><a name="Q2: Wat heeft Vanar ertoe gebracht om de focus te verleggen van NFT/Metaverse naar een breder blockchain-aandachtsgebied?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat heeft Vanar ertoe gebracht om de focus te verleggen van NFT/Metaverse naar een breder blockchain-aandachtsgebied?</h3><p><strong>Mohammed</strong>: Onze overstap werd gemotiveerd door de problemen waarmee mainstream bedrijven te maken hebben met blockchaintechnologie - het begrijpen ervan, het beheren van wallets, het afhandelen van transacties, het omgaan met fluctuerende gasprijzen en het omgaan met meerdere marktplaatsen van derden. We zagen een kans om dit proces te vereenvoudigen en een one-stop shop te worden voor deze merken. En ze zijn er dol op. Deze verschuiving stelt ons in staat om gestroomlijnde, gebruiksvriendelijke blockchains oplossingen aan te bieden, waardoor technologie toegankelijk en beheersbaar wordt voor onze partners.</p>
<h3 id="h3-Q320Kunt20u20meer20vertellen20over20de20samenwerkingen20van20Vanar20en20wat20er20in20de20nabije20toekomst20te20verwachten20is90049"><a name="Q3: Kunt u meer vertellen over de samenwerkingen van Vanar en wat er in de nabije toekomst te verwachten is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kunt u meer vertellen over de samenwerkingen van Vanar en wat er in de nabije toekomst te verwachten is?</h3><p><strong>Mohammed</strong>: Vanar’s partnerschappen zijn een bewijs van onze baanbrekende aanpak in de blockchainruimte. Naast onze toekomstplannen hebben we succesvolle samenwerkingen gehad met bekende merken zoals Paramount, Legendary, Shelby en Kevin Hart. Onze samenwerking met Emirates Digital Wallet, eigendom van de 16 grootste banken in de Emiraten, illustreert onze toewijding aan financiële innovatie. Met Google Cloud, vooral na onze recente AMA met hen, werken we eraan om de meest energie-efficiënte blockchain te worden, waarbij we onze nodes op duurzame energie laten draaien.</p>
<p>Alleen deze maand brengen we een gamestudio binnen met ongeveer 1 miljard downloads verspreid over hun games en 100 miljoen gebruikers. Deze samenwerkingen geven slechts een glimp van hoe we de grenzen verleggen in de blockchain-ruimte.</p>
<h3 id="h3-Q420Kunt20u20ons20iets20vertellen20over20het20team20achter20Vanar20vooral20belangrijke20figuren20zoals20Doug20Dyer20Gary20Bracey20en20Jawad20Ashraf20179"><a name="Q4: Kunt u ons iets vertellen over het team achter Vanar, vooral belangrijke figuren zoals Doug Dyer, Gary Bracey en Jawad Ashraf?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kunt u ons iets vertellen over het team achter Vanar, vooral belangrijke figuren zoals Doug Dyer, Gary Bracey en Jawad Ashraf?</h3><p><strong>Mohammed</strong>: Bij Vanar zijn we trots op onze krachtige groep industrieleiders. Doug Dyer, een titan in gaming en entertainment, brengt een schat aan inzichten en connecties met zich mee. Zijn opmerkelijke staat van dienst omvat cruciale rollen in games zoals Microsoft’s ‘Age of Empires’ en Warner Bros.’s ‘Harry Potter’, evenals het feit dat hij medeoprichter is van de gamingreus THQ.</p>
<p>Gary Bracey, onze mede-oprichter en voorzitter, is een ware pionier in de gamingindustrie. Hij heeft geschiedenis geschreven door de eerste film-IP in een game te licenseren met ‘RoboCop’ bij Ocean Software. Zijn diepe connecties en begrip van de gamingindustrie zijn van onschatbare waarde voor de visie en strategie van Vanar.</p>
<p>Jawad Ashraf, onze medeoprichter en CEO, is een bekende ondernemer in Dubai, bekend om zijn technische expertise en zakelijk inzicht. Met succes meerdere technologiebedrijven verlaten met waarderingen van meer dan $100M, brengt Jawad een unieke mix van technische kennis en ondernemerservaring om de reis van Vanar te begeleiden.</p>
<p>Samen zorgen deze leiders, gesteund door ons team van meer dan 150 professionals, voor de missie van Vanar om te innoveren en uit te blinken in de blockchain ruimte.</p>
<h3 id="h3-Q520Hoe20verschilt20Vanar20van20andere20nieuwe20blockchains20die20opkwamen20in20202220en20202320Wat20maakt20het20anders711501"><a name="Q5: Hoe verschilt Vanar van andere nieuwe blockchains die opkwamen in 2022 en 2023? Wat maakt het anders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe verschilt Vanar van andere nieuwe blockchains die opkwamen in 2022 en 2023? Wat maakt het anders?</h3><p><strong>Mohammed</strong>: Vanar onderscheidt zichzelf door middel van een unieke mix van functies en de bruikbaarheid van onze token, $VANRY. Onze focus op lage transactiekosten en hoge snelheid prestaties, in combinatie met DApps als een service, past perfect bij mainstream partners, wat zorgt voor een brede acceptatie. De bruikbaarheid van $VANRY in dit ecosysteem verbetert de gebruikersbetrokkenheid en stimuleert deelname, waardoor het meer is dan alleen een valuta - het is een essentieel onderdeel van onze blockchain-infrastructuur.<br><img src="https://gimg2.gateimg.com/image/article/17024491404.jpeg" alt=""><br>Bovendien positioneert onze nadruk op groene energie, vooral door onze samenwerking met Google Cloud, ons als leider in duurzame blockchaintechnologie. Deze benadering, samen met het strategische nut van $VANRY, onderscheidt ons, waardoor Vanar niet alleen een blockchaintoepassing is, maar een allesomvattend, milieubewust ecosysteem voor de toekomst van gedecentraliseerde toepassingen en digitale handel.</p>
<h2 id="h2-Live20QampA20vanuit20de20community504432"><a name="Live Q&amp;A vanuit de community" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live Q&amp;A vanuit de community</h2><h3 id="h3-Q120Kunt20u20enkele20hoogtepunten20noemen20van20het20team20achter20uw20project20Wat20is20uw20achtergrond20en20ervaring20die20hebben20bijgedragen20aan20het20ontstaan20van20het20platform20en20die20de20visie20en20toekomstige20ontwikkeling20hebben20gewaarborgd20Dit20is20belangrijk20om20het20vertrouwen20van20investeerders20te20verdienen311275"><a name="Q1: Kunt u enkele hoogtepunten noemen van het team achter uw project? Wat is uw achtergrond en ervaring die hebben bijgedragen aan het ontstaan van het platform en die de visie en toekomstige ontwikkeling hebben gewaarborgd? Dit is belangrijk om het vertrouwen van investeerders te verdienen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u enkele hoogtepunten noemen van het team achter uw project? Wat is uw achtergrond en ervaring die hebben bijgedragen aan het ontstaan van het platform en die de visie en toekomstige ontwikkeling hebben gewaarborgd? Dit is belangrijk om het vertrouwen van investeerders te verdienen.</h3><p><strong>Mohammed</strong>: Ik heb veel gesproken over het team - maar de vraag is zeer relevant. Veel projecten beloven zoveel, maar kunnen dit niet waarmaken door marktkrachten of gebrek aan ervaring. We hebben een team dat meerdere technologische cycli heeft doorlopen, van basis-pc, tot gaming, tot console, tot mobiel, vervolgens web3, XR en AI. Het begrijpen van de beste ‘technologiepasvorm’ is wat een merk laat voortbestaan en groeien. Als we alleen maar blijven praten tegen een klein publiek, kunnen we niet doorbreken naar een breder publiek. We willen dat Vanar net zo synoniem wordt met web3-technologie en uitgebreide economieën en gamefi als erkende merken zoals Microsoft of Google. Daarom moet je mensen hebben met de ervaring om niet alleen te innoveren, maar ook moeilijke markten te navigeren. We zijn al lang actief, ondanks de winter, beren, enzovoort! En we zijn er nog steeds en bouwen verder.</p>
<h3 id="h3-Q220Op20welke20manieren20lost20Vanar20de20uitdagingen20op20waarmee20reguliere20bedrijven20te20maken20hebben20met20blockchain20technologie20inclusief20problemen20met20portefeuilles20transacties20en20gasprijzen244847"><a name="Q2: Op welke manieren lost Vanar de uitdagingen op waarmee reguliere bedrijven te maken hebben met blockchain technologie, inclusief problemen met portefeuilles, transacties en gasprijzen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Op welke manieren lost Vanar de uitdagingen op waarmee reguliere bedrijven te maken hebben met blockchain technologie, inclusief problemen met portefeuilles, transacties en gasprijzen?</h3><p><strong>Mohammed</strong>: Grote bedrijven worden geconfronteerd met veel uitdagingen in deze ruimte, allereerst bij het begrijpen van wat de kans zelf is. Sommigen zijn erg bang voor crypto, of ze begrijpen het niet, ze associëren het met iets scammy. En die bedrijven die een activatie doen, realiseren zich vaak niet de implicaties en worden geconfronteerd met veel FUD als ze iets niet goed doen. Er heerst een andere cultuur in web3. Vanuit een zakelijk perspectief hebben ze ook problemen met het niet kunnen beheersen van de gebruikersreis op een manier die past bij hun merk, tech-partners die veel beloven en niet kunnen leveren, milieuzorgen en uiteraard wat je noemde, i.e. variabele gas kosten, hoge TX-kosten en verwarring rond portefeuilles. Ons doel is om dat te vereenvoudigen - we hebben vaste kosten, we hebben portefeuilletools waarmee ze hun gebruikers gemakkelijk kunnen beheren, en onze dapps stellen hen in staat om op een manier in de ruimte te komen die voor hen werkt. Dat kan een hele productverticale zijn in web3, of het kan gewoon één activatie of evenement zijn. Ons doel is om hen te omringen met de tools die ze nodig hebben.</p>
<h3 id="h3-V320Welke20plannen20heeft20u20voor20de20toekomst20van20Vanarchain20en20hoe20wilt20u20het20ecosysteem20van20innovatie20en20samenwerking20tussen20ontwikkelaars20gebruikers20en20bedrijven20laten20groeien769759"><a name="V3: Welke plannen heeft u voor de toekomst van Vanarchain en hoe wilt u het ecosysteem van innovatie en samenwerking tussen ontwikkelaars, gebruikers en bedrijven laten groeien?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Welke plannen heeft u voor de toekomst van Vanarchain en hoe wilt u het ecosysteem van innovatie en samenwerking tussen ontwikkelaars, gebruikers en bedrijven laten groeien?</h3><p><strong>Mohammed</strong> We hebben GROTE plannen. Het beginnen met Google was opzettelijk om aan te geven hoe groot we willen gaan. Over sport, muziek, gaming, entertainment willen we impact maken, ontwikkelaars opleiden en het ecosysteem laten groeien. We zijn ook in gesprek met nationale broedplaatsen in 3 landen, om Vanar het platform van het land te maken waar lokale ontwikkelaars kunnen bouwen en ontwikkelen om een gezond ecosysteem te creëren waar innovatie kan plaatsvinden en ook lokale markten kan bedienen. Er zijn kansen op veel gebieden, niet alleen beperkt tot entertainment, gaming maar ook identiteit, supply chain en nog veel meer. We zullen informatie vrijgeven over ons ondersteuningsprogramma voor ontwikkelaars, met een speciaal kanaal voor ontwikkelaars. Educatie is zo belangrijk voor dit. We beschouwen iedereen als een gewaardeerde partner waar we samen kunnen groeien. Vanar is EVM dus het is gemakkelijk om op te bouwen en ook vertrouwd voor ontwikkelaars. Zoals ik al zei, draait het allemaal om het bouwen van technologie die het ‘beste past’ in plaats van alleen maar te praten over hoe geweldig de technologie is omwille daarvan.</p>
<h3 id="h3-Q420Hoe20pakt20Vanar20Eco20belangrijke20pijnpunten20aan20voor20merken20in20de20blockchainruimte864520"><a name="Q4: Hoe pakt Vanar Eco belangrijke pijnpunten aan voor merken in de blockchainruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe pakt Vanar Eco belangrijke pijnpunten aan voor merken in de blockchainruimte?</h3><p><strong>Mohammed</strong>: We kunnen zoveel merken tellen die niet in <a href="/web3" target="_blank" class="blog_inner_link">web3</a> wilden stappen vanwege hun zorgen over de impact van de technologie. Maar niet alleen dat, uit onderzoeken blijkt nu dat 70% van genz verwacht dat de merken waarmee ze werken verantwoordelijk zijn tegenover het milieu.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>