R2F0ZS5pbyBBTUEgbWV0IFRocm9uZSBMYWJzIC0gRWVuIGJsb2NrY2hhaW5iZWRyaWpmIGRhdCBidWl0ZW5nZXdvbmUgZXJ2YXJpbmdlbiBib3V3dCB2b29yIGhldCBnZWRlY2VudHJhbGlzZWVyZGUgd2Vi

<p><img src="https://gimg2.gateimg.com/image/article/16808360811.jpg" alt=""><br><strong>Tijd: 26 apr. 2022, 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 Zac Lewis, CEO van Throne Labs 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://www.thronelabs.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.thronelabs.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/thronelabs" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/thronelabs</a></strong><br><strong>Volg Throne Labs op <a href="https://discord.gg/h33GQ97hzM" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://twitter.com/thronelabs" rel="nofollow noopener noreferrer" target="_blank">Sjilpen</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16808363202.png" alt=""><br><strong>Zac Lewis - CEO van Throne Labs</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio993862"><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-Q120Kun20je20ons20alsjeblieft20meer20vertellen20over20Throne433232"><a name="Q1: Kun je ons alsjeblieft meer vertellen over Throne?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons alsjeblieft meer vertellen over Throne?</h3><p><strong>Zac</strong>: Throne Labs is een blockchainbedrijf dat buitengewone ervaringen bouwt voor het gedecentraliseerde web, ook wel bekend als Web3.<br>Het is een basis waar gebruikers hun eigen gegevens bezitten, digitale transacties veilig zijn en uitwisselingen van informatie en waarde gedecentraliseerd zijn.</p>
<p>$THN is de utility token voor de Throne community, het netwerk en het ecosysteem dat is ontworpen om platforms te democratiseren en een infrastructuur te bieden voor de economie van morgen.</p>
<p>Web3 is een zeer populaire iteratie van een evolutie van Web2 die concepten zoals decentralisatie en op tokens gebaseerde economieën incorporeert.</p>
<p>Op het meest basale niveau verwijst <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> naar een gedecentraliseerd online ecosysteem gebaseerd op de blockchain.</p>
<p>Platforms en apps die op Web3 zijn gebouwd, zullen niet eigendom zijn van een centrale poortwachter, maar van gebruikers, die hun eigendomsbelang zullen verdienen door te helpen bij het ontwikkelen en onderhouden van die diensten.</p>
<p>We zijn in de late 2020 begonnen met onze verkenningfase en hebben ons formeel in 2021 gevestigd. We zijn een nogal diverse team, verspreid over de hele wereld, met mijzelf in New York en de rest van het team in Singapore, Los Angeles, Dubai en Londen.<br><img src="https://gimg2.gateimg.com/image/article/16808363583.png" alt=""><br>U wordt uitgenodigd om onze website te bekijken: <a href="https://thr.one" rel="nofollow noopener noreferrer" target="_blank">https://thr.one</a></p>
<h3 id="h3-Q220Kunt20u20ons20ook20iets20vertellen20over20uzelf20het20team20en20de20oprichters336935"><a name="Q2: Kunt u ons ook iets vertellen over uzelf, het team en de oprichters?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons ook iets vertellen over uzelf, het team en de oprichters?</h3><p><strong>Zac</strong>: Throne Labs wordt ondersteund door een collectief van blockchain-ingenieurs en geleid door een bekwaam team uit het creatieve en culturele domein.</p>
<p>De medeoprichters zijn onder andere de Britse prijswinnende muziekproducent Nellee Hooper (bekend van zijn werk met Madonna, U2), de ervaren mediabestuurder Gee Roberson, de manager van Kanye West (voormalig manager van Drake, Nicki Minaj), Chimere Cisse, voormalig communicatiemedewerker bij Burberry, alumni van het Sotheby’s Institute Julia Pavlovska, veteraan blockchain architect Anthony Karter en blockchain durfkapitalist Qinghua Li.</p>
<p>Ik ben vanaf het begin betrokken geweest bij het project, maar ben aan het begin van 2022 aangetreden als CEO.</p>
<p>Ik ben 48 jaar oud, ik ben geboren en getogen in Hong Kong, ik ben opgeleid in Londen en New York, ik heb een graad in Computerwetenschappen van de Fordham University.</p>
<p>Voordat ik me bij de oprichters van Throne Labs voegde, werkte ik bij Pluto TV, de grootste online televisiedienst met meer dan 60 miljoen gebruikers. Pluto TV werd in 2019 voor $320 miljoen verkocht aan Viacom. Ik was een van de allereerste werknemers, eigenlijk nummer 2, die direct samenwerkte met oprichter Ilya Pozin, zowel voor als na de lancering.</p>
<p>Bij Throne ben ik hier om het project vooruit te leiden en de strategie voort te zetten naarmate we dieper en dieper doordringen in toepassingen die het Web3-ecosysteem ondersteunen, inclusief integratie met andere blockchains zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>.</p>
<p>Het is een zeer spannende tijd voor ons allemaal en een nederige ervaring voor mij.</p>
<h3 id="h3-Q320En20wat20heb20je20gebouwd20en20wat20heb20je20tot20nu20toe20gebouwd457355"><a name="Q3: En wat heb je gebouwd en wat heb je tot nu toe gebouwd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: En wat heb je gebouwd en wat heb je tot nu toe gebouwd?</h3><p><strong>Zac</strong>: Ons algemene doel is om toonaangevende toepassingen te bieden voor het gedecentraliseerde web. Dit omvat platforms waar gebruikers hun eigen gegevens, identiteit en lot controleren.</p>
<p>We zijn een mix van software engineers, kunst- en mediaprofessionals, die invloed uitoefenen op de hedendaagse cultuur in onze ontwikkelingen en methodologie.</p>
<p>We hebben een prachtig NFT-platform gebouwd en succesvol gelanceerd dat wordt gebruikt door enkele zeer getalenteerde kunstenaars.</p>
<p><a href="https://Throne.Market" rel="nofollow noopener noreferrer" target="_blank">https://Throne.Market</a></p>
<p>Een van onze oprichters, Gee Roberson, is al meer dan twee decennia actief in de creatieve wereld. Hij heeft samengewerkt met Jay Z als hoofd van A&amp;R bij Roca-Fella-Rocrds en bij Atlantic Records. Hij was voorheen manager voor iconische talenten als Drake, Lil Wayne en Nicki Minaj. Vandaag de dag is hij de manager van Kanye West, dus we geloven sterk in esthetiek, design en de integriteit van het product. We besteden veel aandacht aan detail, zoals we intern zeggen ‘Elke pixel telt’.</p>
<p>We zijn nu ook bezig met het bouwen van Throne City, een levendige stad in de metaverse, bestuurd door de THN-gemeenschap.<br>Throne City Metaverse biedt een hoogwaardige meeslepende ervaring in een metaverse die wordt gecontroleerd door de grondeigenaren.<br>In tegenstelling tot andere metaversen, besturen de bewoners de stad en de buurtplanning, inclusief de goedkeuring van architectuur- en bouwplannen voor hun stad.</p>
<p>In plaats van een vrije metaverse waar iedereen alles kan doen, of een centraal gecontroleerde omgeving, biedt Throne City een doordacht planningsproces waarbij de deelnemers een democratisch proces van stemmen gebruiken om te reguleren hoe hun stad en buurten zich zullen ontwikkelen.</p>
<p>Throne City’s traject is erop gericht om binnen vier jaar volledig in het bezit te zijn van de deelnemers, en om te worden bestuurd via een stemmechanisme, gebaseerd op bestuur tokens op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk.<br><img src="https://gimg2.gateimg.com/image/article/16808363394.jpg" alt=""><br>Ik wil graag met u delen een kort glimp van wat er komen gaat. Dus neem alstublieft een kijkje op deze <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">VERBINDEN</a>:<br><a href="https://www.youtube.com/watch?v=3qndEeE5AIU" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/watch?v=3qndEeE5AIU</a></p>
<h3 id="h3-V420Heeft20u20in20de20nabije20toekomst20evenementen20gepland78207"><a name="V4: Heeft u in de nabije toekomst evenementen gepland?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Heeft u in de nabije toekomst evenementen gepland?</h3><p><strong>Zac</strong>: Natuurlijk doen we dat!<br>In de nabije toekomst zijn we van plan om THN te airdroppen naar $MANA ( <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a>) houders, omdat we ze beschouwen als de beste houders van THN op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk. We willen dat zij de eersten zijn die bepalen hoe Throne City eruit zal zien, dus blijf op de hoogte voor de details op onze sociale media.<br>Daarnaast organiseren we wekelijks allerlei competities op onze Discord-server, kom eens kijken!</p>
<h3 id="h3-V520En20waar20kan20de20gemeenschap20uw20token20kopen297637"><a name="V5: En waar kan de gemeenschap uw token kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: En waar kan de gemeenschap uw token kopen?</h3><p><strong>Zac</strong>: Onze eigen token is Throne, met de tickersymbool $THN<br>Sinds we Throne 6 maanden geleden hebben geïntroduceerd, is er meer dan $300M verhandeld.<br>We handelen op Gate.io en een paar anderen.<br>In de komende maanden zal je het ook zien toegevoegd worden aan enkele andere grote beurzen naast Gate.io<br>Het zal geweldig zijn om jullie welkom te heten in onze THN-community, we hebben hele grote plannen in petto!</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 opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>