VGhlIFNhbmRib3g6IFJpZGluZyB0aGUgV2F2ZSB0byBhICQxIEJpbGxpb24gVmFsdWF0aW9uIGluIHRoZSBFdGhlcmV1bSBNZXRhdmVyc2U=

2024-06-19, 08:21

<p><img src="https://gimg2.gateimg.com/image/article/17187847721690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR184920"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Animoca Brands en Kingsway Capital hebben de Sandbox geholpen om $1 miljoen op te halen voor de verbetering van verschillende functies en mogelijkheden.</p>
<p><a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">De Sandbox</a> heeft een waardering van $1 miljard, wat wijst op zijn gestage groei in de loop der jaren.</p>
<p>The Sandbox streeft ernaar om zijn makerstools en gameplay-functies te verbeteren.</p>
<h2 id="h2-Introductie399380"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De introductie van de metaverse heeft de manier veranderd waarop mensen met elkaar omgaan. Dat heeft ook een nieuwe manier van geld verdienen geïntroduceerd omdat mensen gemakkelijk kunnen deelnemen aan de metaverse economie. Voorbeelden van toonaangevende metaverse economieën zijn <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> en Sandbox. In dit artikel behandelen we de fondsenwerving en uitbreidingsdoelstellingen van Sandbox.</p>
<p>Eigenlijk, <a href="https://www.gate.io/learn/articles/what-is-the-sandbox/88" target="_blank">Sandbox is een gedecentraliseerd gamingplatform</a> gebouwd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Het heeft digitale stukken land, vertegenwoordigd door niet-fungibele tokens, die mensen kunnen kopen en virtuele activa zoals onroerend goed kunnen vestigen.</p>
<h2 id="h2-The20Sandbox20Raised202020Miljoen20in20een20Recent20Financieringsronde304967"><a name="The Sandbox Raised 20 Miljoen in een Recent Financieringsronde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>The Sandbox Raised 20 Miljoen in een Recent Financieringsronde</h2><p>Sandbox, het metaverse platform, is <a href="https://www.gate.io/blog_detail/409/the-sandbox-everything-you-need-to-know" target="_blank">een van de nieuwste crypto-unicorns</a> dat gedecentraliseerde digitale diensten biedt in de vorm van virtuele activa. Animoca Brands, het moederbedrijf van Sandbox, en Kingsway Capital speelden een grote rol bij het ophalen van $20 miljoen voor Sandbox. Na het ophalen van $20 miljoen aan promessen verdiende de nieuwe crypto-unicorn een waardering van $1 miljard. De andere bedrijven die deelnamen aan de inzamelingsactiviteit zijn Bacasable Global Limited, LG Tech Ventures en True Global Ventures.</p>
<p>Sandbox’s recent financiering kwam twee jaar nadat het oorspronkelijke plan om $400 miljoen op te halen tegen een waardering van $4 miljard. De houders van de promessenoten kunnen de investeringsinstrumenten gemakkelijk omzetten in Bacasable Global-aandelen.</p>
<h2 id="h2-Yat20Sius20visie20op20de20toekomst20van20het20Sandboxplatform734601"><a name="Yat Siu’s visie op de toekomst van het Sandbox-platform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Yat Siu’s visie op de toekomst van het Sandbox-platform</h2><p>Onlangs zei Yat Siu, mede-oprichter van Animoca Brands, dat Sandbox zich richt op “de evolutie van UGC-games voor het tijdperk van digitale eigendom.” In een persbericht. <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">Arthur Madrid, medeoprichter en CEO van Sandbox, zei</a> Onze missie bij <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> is het ontwikkelen van creatieve tools en technologieën die eerlijkheid en nieuwe kansen bieden voor alle soorten makers in de open metaverse.</p>
<p><a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">In een vergelijkende verklaring zei Siu</a> We zijn diep vereerd door het voortdurende engagement met de visie van The Sandbox, en we zijn ontzettend enthousiast over de toekomst van samenstelbare door gebruikers gegenereerde content games.</p>
<p>Madrid voegde eraan toe: “Met onze investeerders delen we een visie op de metaverse. Ze zien ook dat Roblox manieren vindt om een nieuwe vorm van onderdompelende ervaring te bereiken. Wij richten ons op Azië en daar is een compleet andere kijk op de markt. Azië is een compleet andere markt als het gaat om Web3.”</p>
<h2 id="h2-De20ontwikkelingsprioriteiten20van20de20sandbox329634"><a name="De ontwikkelingsprioriteiten van de sandbox" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ontwikkelingsprioriteiten van de sandbox</h2><p>Na het ophalen van de $ 20 miljoen heeft het Sandbox-team zich voorgenomen om in 2024 verschillende doelen te bereiken. De belangrijkste doelstellingen van het team zijn onder meer het ontwikkelen van een mobiele versie die in 2025 moet worden gelanceerd, het verbeteren van creator-tools en nieuwe gameplay-functies. Naast het ontwikkelen van een gedecentraliseerde metaverse voor mobiele apparaten, zal Sandbox het geld gebruiken om zijn 3D-editortools en Game Maker bij te werken.</p>
<p>Siu wil dat Sandbox zijn gebruikers unieke voordelen biedt, onvergelijkbaar met andere spelplatforms. Hij verduidelijkte <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">zijn visie toen hij zei</a>, “Vandaag de dag zijn spellen zoals Minecraft en Roblox enkele van de meest populaire titels ter wereld, maar ze bieden hun gebruikers geen digitale eigendomsrechten. The Sandbox vertegenwoordigt de evolutie van UGC-games voor het tijdperk van digitale eigendom.”</p>
<p>Madrid heeft de toekomstige ambities van Sandbox uitgebreid. Hij zei: “De open metaverse stelt iedereen in staat zichzelf uit te drukken terwijl ze ontdekken en in contact komen met de cultuur van miljoenen andere gebruikers. Onze missie bij The Sandbox is het ontwikkelen van creatieve tools en technologieën die eerlijkheid en nieuwe kansen bieden voor alle soorten makers in de open metaverse op alle gebieden van cultuur, met name games, muziek, mode, kunst, sport en entertainment.”</p>
<p>Op weg naar haar belangrijkste doelstellingen heeft Sandbox verschillende doelstellingen bereikt, waaronder het mogelijk maken van haar virtuele landeigenaren om hun unieke LAND-ervaringen aan het publiek te publiceren. Het heeft ook een marktplaats opgezet. <a href="https://www.gate.io/learn/articles/what-is-polygon-2/899" target="_blank">op Polygon’s L2</a> waarmee de makers hun virtuele activa kunnen ontwikkelen en verkopen, waardoor het platform is uitgegroeid tot een bloeiende economie.</p>
<p>Lees ook over <a href="https://www.gate.io/price-prediction/the-sandbox-sand" target="_blank">The Sandbox (SAND) Prijsvoorspelling 2024-2030</a></p>
<h2 id="h2-De20Sandbox20in20het20Metaverse20Ecosysteem135120"><a name="De Sandbox in het Metaverse Ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Sandbox in het Metaverse Ecosysteem</h2><p>The sandbox is een van de toonaangevende metaverse-economieën met meer dan 125.000 makers en miljoenen gebruikers. Onlangs hebben de gedecentraliseerde virtuele platforms meer dan 330.000 unieke makers toegevoegd die al de no-code Game Maker van The Sandbox hebben gedownload. Aan de andere kant, <a href="https://www.gate.io/how-to-buy/the-sandbox-sand" target="_blank">SAND, de inheemse cryptocurrency van Sandbox</a> bevindt zich binnen de top 100 crypto-activa, gebaseerd op marktkapitalisatie. Het concurreert met andere toonaangevende metaverse-gebaseerde tokens zoals MANA voor Decentraland.</p>
<p>Er zijn verschillende redenen waarom Sandbox trending is. Ten eerste beloont het metaverse-platform makers voor hun creativiteit. Bijvoorbeeld, wanneer spelers hun virtuele bezittingen verkopen op de marktplaats, verdienen ze crypto tokens. Op dezelfde manier verdienen ze ook tokens wanneer ze hun spellen monetizen of hun NFT Land-plots verhuren aan andere gamers.</p>
<p>In gerelateerd nieuws lanceerde The Sandbox een gedecentraliseerde autonome organisatie (DAO) die de tokenhouders in staat zal stellen deel te nemen aan de besluitvorming over ontwikkelingskwesties zoals de introductie van nieuwe functies. De Sandbox-gebruikers die eigenaar zijn van de <a href="https://www.gate.io/trade/SAND_USDT" target="_blank">SAND-token</a> Spelers die virtuele grondpercelen bezitten die gebaseerd zijn op NFT’s, krijgen de kans om voorstellen te doen of te stemmen over verschillende aspecten van het spel, zoals nieuwe spelkenmerken, upgrades, beloningen of toekomstige evenementen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/top-10-best-metaverse-virtual-worlds-with-land-nfts/1602" target="_blank">Top 10 Beste Metaverse Virtuele Werelden met Land NFTs</a></p>
<h2 id="h2-Het20effect20van20beroemdheid20en20merkpartnerships608346"><a name="Het effect van beroemdheid en merkpartnerships" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het effect van beroemdheid en merkpartnerships</h2><p>Zandbak <a href="https://www.gate.io/learn/articles/what-is-the-sandbox-how-to-join-the-metaverse/1599" target="_blank">boost van veel metaverse partnerschappen</a> die meer dan 250 vertrouwde partners omvat, zoals bureaus en personen die zijn opgeleid en gecertificeerd door The Sandbox om IP-houders te helpen bij het creëren van metaverse-ervaringen voor hun volgers. De partners helpen ook bij het promoten van het Sandbox-merk.</p>
<p>Op dit moment werkt Sandbox samen met partners uit verschillende regio’s, waaronder Afrika, Vietnam en Saudi-Arabië. Voorbeelden van wereldwijde merken die zich hebben aangesloten bij Sandbox zijn Lionsgate, Hellboy, Ubisoft, Magnificent Century, Habbo, Warner Music en Space Invaders in Shibuya109. Naast deze merken wordt het Sandbox-ecosysteem ondersteund door veel beroemdheden, waaronder Snoop Dogg, Gucci, Notorious BIG en Paris Hilton.</p>
<p>Met betrekking tot dit <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">Borget zei</a> We zijn verheugd om nieuwe strategische partners te verwelkomen die onze visie ondersteunen om het meest toegankelijke en inclusieve platform te ontwikkelen dat de mogelijkheden van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> beschikbaar maakt voor een wereldwijd mainstream publiek, en waar merken en gemeenschappen de handen ineenslaan om samen de toekomst van gaming en entertainment te creëren. The Sandbox is een trotse gelover in de kracht van de metaverse om onze digitale toekomst vorm te geven als collaboratief, eerlijk en open.</p>
<p>Omdat deze beroemdheden een groot aantal volgers hebben, trekken ze spelers aan naar het Sandbox-spel. Sommige van deze gebruikers investeren in verschillende digitale activa zoals virtueel onroerend goed. Bijvoorbeeld, in 2021 betaalde een investeerder $450.000 om een virtueel land naast het metaverse herenhuis van Snoop Dogg te verwerven. Als feit heeft Snoop Dogg zijn herenhuis in Californië gerecreëerd op het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> metaverse gameplatform. In feite wordt het land op de Sandbox verkocht in de vorm van niet-fungibele tokens (NFT’s).</p>
<h2 id="h2-Conclusie885462"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Onlangs heeft the Sandbox $20 miljoen opgehaald om te worden gebruikt voor het verbeteren van zijn infrastructuur. Animoca Brands en Kingsway Capital speelden een centrale rol bij het ophalen van het kapitaal. Nu heeft the Sandbox een waardering van $1 miljard, wat wijst op zijn gestage groei in de loop der jaren. In zijn streven om zijn merk te promoten, heeft The Sandbox partnerschappen gesmeed met diverse organisaties en individuen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>