R2F0ZS5pbyBQb2RjYXN0IHwgIkV0aGVyZXVtIGdhYXQgZmFsZW4iIHpvYWxzIHZlcmtsYWFyZCBkb29yIEphY2sgRG9yc2V5LCBDcnlwdG8taW5mbHVlbmNlciBTaGlsbGluZyBCZXRhbGluZ3NsaWpzdCBnZWxla3QsIFRlc2xhIGdhYXQgQlRDLW1pam5mYWNpbGl0ZWl0IGZpbmFuY2llcmVu

<p><a href="https://gimg2.gateimg.com/image/article/16506012440421LinearFinance_en.jpghttp://" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/image/article/16506012440421LinearFinance_en.jpg" alt=""></a></p>
<p>Deze aflevering wordt u aangeboden door <a href="https://www.gate.io/http://" target="_blank">Gate.io</a> en Linear Finance (<a href="https://www.gate.io/article/26270?ch=lina26270twi#giveawayhttp://" target="_blank">Airdrop</a>). Jack Dorsey bekritiseert <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en verklaart dat het project vele redenen heeft om te mislukken; een lijst vol crypto-influencer-shillingbetalingen is gepubliceerd op Twitter, wat de verbazing van de gemeenschap opwekte; <a href="/price/algorand-algo" target="_blank" class="blog_inner_link">Algorand</a> nam Time Square over om de Earth Day-manifestatie te vieren. Gevolgd door een Deep Dive in hoe techbedrijven omgaan met de overgang naar <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en hoe hun nieuwe producten vorm geven aan een nieuw soort gemeenschapsinteractie tussen mensen en AR.</p>
<hr>
<h3 id="h3-In20de20krantenkoppen20van20vandaag903468"><a name="In de krantenkoppen van vandaag:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In de krantenkoppen van vandaag:</h3><p>Argentinië gaat BTC delven om de inflatie te bestrijden | <a href="https://en.cryptonomist.ch/2022/04/19/argentina-considering-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> |<br>Algorand neemt controle over NY’s Time Square | <a href="https://www.prnewswire.com/news-releases/algorand-to-take-over-times-square-in-new-york-city-this-earth-day-to-advocate-for-a-greener-future-301526807.htmlhttp://" rel="nofollow noopener noreferrer" target="_blank">1</a> |<br>“Ethereum heeft veel Single Points Failure” Zegt Jack Dorsey, de medeoprichter van Twitter | <a href="https://news.[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> | <a href="https://decrypt.co/98160/jack-dorsey-ethereum-many-single-points-failurehttp://" rel="nofollow noopener noreferrer" target="_blank">2</a> |<br>Beïnvloeders Crypto Shilling Betalingslijst gelekt | <a href="https://en.ethereumworldnews.com/how-much-twitter-influencers-get-paid-to-shill-crypto-projects/http://" rel="nofollow noopener noreferrer" target="_blank">1</a> |<br>Tesla investeert in BTC mijnbouwfaciliteit | <a href="https://www.independent.co.uk/tech/tesla-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a>  |</p>
<p>Sponsor: Linear Finance (<a href="https://www.gate.io/article/26270?ch=lina26270twi#giveawayhttp://" target="_blank">Airdrop</a>)<br>Deep Dive: Welke producten ontwikkelen technische bedrijven voor de Web3-revolutie?  | <a href="https://www.gate.io/blog_detail/814/Snapchat-And-Metaversehttp://" target="_blank">1</a> | <a href="https://www.gate.io/blog_detail/832/Adobe-s-Plans-For-the-Metaversehttp://" target="_blank">2</a> | <a href="https://www.gate.io/blog_detail/824/Amazon-hits-the-Metaverse-with-a-3D-gamehttp://" target="_blank">3</a> | <a href="https://www.gate.io/blog_detail/852/How-Most-Web2-Companies-Are-Adopting-The-Web3-Technologyhttp://" target="_blank">4</a> |<br>Luister: <a href="https://www.buzzsprout.com/1825729/10482340" rel="nofollow noopener noreferrer" target="_blank">https://www.buzzsprout.com/1825729/10482340</a></p>
<hr>
<h3 id="h3-Introduction426967"><a name="Introduction:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduction:</h3><p>Welcome back to the Altcoin News Podcasts. I’m Peter, this is the show to get a neutral perspective on some of the latest headlines in DeFi, Metaverse, NFTs, and Big Tech. Brought to you by Gate.io, a centralized exchange with a neutral stance on current events and uphold privacy &amp; security.</p>
<p>The information presented in this podcast is to help you stay up-to-date on the latest happening in the crypto space, and nothing presented hereby is financial advice. The news that I cover in this podcast will have the original source at your discretion. Stick by this podcast as I show you how to stay vigilant and learn to do your own research.</p>
<p>Now, without further ado.</p>
<h3 id="h3-Argentini20gaat20BTC20delven20om20inflatie20te20bestrijden2020202012020611854"><a name="Argentinië gaat BTC delven om inflatie te bestrijden |   1  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argentinië gaat BTC delven om inflatie te bestrijden | <a href="https://en.cryptonomist.ch/2022/04/19/argentina-considering-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> |</h3><p>Veel Zuid-Amerikaanse landen worden getroffen door hoge inflatie, vooral landen als Venezuela of, zoals in dit g, Argentinië. Een van de eerste oplossingen, om de inflatie te bestrijden, was het invoeren van cryptocurrencies; daarom heeft een stad als Rio De Janeiro onlangs aangekondigd dat haar economie een nieuwe strategie gaat volgen die gericht is op het invoeren van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, waardoor haar burgers belasting kunnen betalen en andere betalingen kunnen doen via virtuele valuta.</p>
<p>Afgelopen zomer leek Argentinië een nieuwe weg in te slaan naar de acceptatie van cryptocurrencies, die kort daarna werd stopgezet vanwege eventuele IMF-beperkingen. </p>
<p>In juli 2021 diende het Argentijnse parlementslid José Luiz Ramon een wetsvoorstel in om salarissen betaald in <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> in te voeren. en in andere cryptocurrencies. Bovendien kondigde president Alberto Fernandez van het land aan dat er een serieuze strategie werd gepland om het gebruik van cryptocurrencies aan te moedigen en dat de centrale bank overwoog een digitale staatsmunt in te voeren.</p>
<p>Alles mislukte echter in maart, toen Argentinië een overeenkomst tekende met het IMF, die een einde maakte aan elke mogelijkheid tot adoptie van crypto in het land, in ruil voor financiële steun van bijna $45 miljard. </p>
<p>De hoge inflatie blijft de binnenlandse economie schaden, daarom heeft het Argentijnse stadje Serodino besloten tegen het financiële besluit van het land in te gaan en de mijnbouw van cryptocurrencies te omarmen: op 10 april kocht het zes mijnbouwinstallaties. </p>
<p>Ook al zijn er veel zorgen geuit door de gemeenschap vanwege de volatiliteit van cryptocurrencies, heeft de burgemeester zijn burgers verzekerd dat de stad geen crypto’s zal kopen, maar dat de hele investering zal dienen om mijnbouwactiviteiten te financieren, wat hij beschouwt als een veilige uitgave. </p>
<p>Ondanks de onzekerheid van zijn waarde, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> lijkt te worden beschouwd als de oplossing voor veel landen om de volatiliteit van hun eigen nationale valuta te beheersen en af te remmen, een besluit dat nog meer steden en landen kan aanmoedigen om hetzelfde initiatief te nemen en de hoge inflatie te bestrijden die momenteel de wereldeconomieën schaadt.</p>
<h3 id="h3-Algorand20Takes20Control20Over20NYs20Time20Square2020202012020526396"><a name="Algorand Takes Control Over NY’s Time Square |   1  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Algorand Takes Control Over NY’s Time Square | <a href="https://www.prnewswire.com/news-releases/algorand-to-take-over-times-square-in-new-york-city-this-earth-day-to-advocate-for-a-greener-future-301526807.htmlhttp://" rel="nofollow noopener noreferrer" target="_blank">1</a> |</h3><p>Algorand took over Times Square yesterday, on the occasion of the Earth Day celebrations. </p>
<p>The peculiarity of their advertisement? All the billboards were turned off.<br>This approach showcases Algorand’s commitment to sustainability and energy efficiency, while also bringing a rare moment of calm in one of the busiest and most famous places in the world.<br>The take over lasted for one hour, from 8 am to 9 am, just as the celebrations around the globe kicked-off.</p>
<p>In an hour, Times Square consumes roughly 6500 kilowatt, which is the equivalent of finalizing 350 million transactions on the Algorand chain, or keeping the network online for approximately 2 weeks.<br>By comparison, the same amount of power is necessary to complete up to six transactions on the <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> network, or sustain the network for just 1.5 seconds.</p>
<p>This impressive performance is one of the key aspects of Algorand, which was built from the start with the intention to achieve speed, scale and decentralization while having a minimal impact on the environment.<br>Considered the world’s first pure proof-of-stake blockchain, Algorand has quickly become a leader in terms of environmentally friendly blockchain technology, with an output of up to 120 million times less CO2 emissions when compared to <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<p>According to Staci Warden, CEO of the Algorand Foundation, the goal of Algorand is to prove that blockchain technology can be energy efficient and powerful at the same time, without compromising on security. She also added that plans to further Algorand’s carbon-negative pledge are in the works.</p>
<p>So what do you think? Is this a publicity stunt, or is it what Algorand truly believes?<br>Transition————-</p>
<p>Thanks again for tuning in. If you enjoy this podcast, make sure to subscribe, turn on that bell, and give us an honest rating on any platform you’re using to listen to our podcast. Help us spread this channel to help educate more people about crypto space. Thank you.</p>
<h3 id="h3-Ethereum20heeft20veel20single20points20failure20zegt20Jack20Dorsey20de20medeoprichter20van20Twitter202020201202020202022020763167"><a name="“Ethereum heeft veel single points failure” zegt Jack Dorsey, de medeoprichter van Twitter |   1  |   2  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Ethereum heeft veel single points failure” zegt Jack Dorsey, de medeoprichter van Twitter | <a href="https://news.[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> | <a href="https://decrypt.co/98160/jack-dorsey-ethereum-many-single-points-failurehttp://" rel="nofollow noopener noreferrer" target="_blank">2</a> |</h3><p>In de afgelopen dagen heeft Dorsey hard getweet tegen veel gebruikers en bedrijven: een van de meest recente zijn de antwoorden uitgewisseld tussen hem en Vlad Tenev die voorstelde om <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> te kopen. via de handelsapp van Robinhood. </p>
<p>Tenev wilde zijn platform promoten als het platform dat goedkopere tarieven biedt: een aanbod waarop Dorsey reageerde en suggereerde dat de CEO van RobinHood alleen uit was op het verhogen van zijn inkomsten, waarbij hij hem ervan beschuldigde “dorstig” te zijn. Het gesprek tussen de twee eindigde met Dorsey die het aanbod weigerde en verklaarde dat hij die dienst niet gebruikte, waarmee hij indirect slechte publiciteit maakte voor de beroemde aandelenapp.<br>Bovendien bleef Jack Dorsey prompt veel zorgen uiten over de Ethereum blockchain, waarbij hij het hele systeem bijna bekritiseerde. De discussie tussen hem en Vitalik Buterin begon nadat eerstgenoemde zijn mening had gegeven over de mogelijkheid dat Elon Musk de controle over Twitter zou overnemen. </p>
<p>Een mening waar Dorsey het mee eens was door er ook aan toe te voegen dat sociale media niet geregeerd moeten worden door individuen of instellingen, maar eerder een open en controleerbaar protocol moeten zijn.</p>
<p>Deso Protocol, een crypto-sociaal mediaplatform, nam ook deel aan het gesprek met als doel zichzelf te promoten, met gebrek aan succes.</p>
<p>De medeoprichter van Twitter antwoordde dat Deso gebaseerd is op het Ethereum-protocol en dat dit de belangrijkste reden is waarom hij niet geïnteresseerd is in het project, waarbij hij Vitaliks project ervan beschuldigde veel faalpunten te hebben. </p>
<p>De vijandigheid van Dorsey tegenover Ethereum is niet nieuw: afgelopen zomer verklaarde hij dat hij helemaal niet van plan was te investeren in de gedecentraliseerde blockchain, wat onzekerheid en onrust veroorzaakte in de cryptogemeenschap, een standpunt dat kan veranderen als Ethereum erin zou slagen over te schakelen van het PoW- naar het PoS-consensusmechanisme, dat opnieuw is uitgesteld tot dit najaar.  </p>
<h3 id="h3-Influencers20Crypto20Shilling20Payment20Leaked20202012020483837"><a name="Influencers Crypto Shilling Payment Leaked |  1  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Influencers Crypto Shilling Payment Leaked |<a href="https://en.ethereumworldnews.com/how-much-twitter-influencers-get-paid-to-shill-crypto-projects/http://" rel="nofollow noopener noreferrer" target="_blank">1</a> |</h3><p>Zachxbt, a member of the crypto community on Twitter famous for his detective-like work of exposing scams, rug pulls and many other foul practices happening in the crypto world, has recently leaked a list of prices that some influencers charge to “shill” a project.</p>
<p>The list contains a total of 115 crypto influencers, with prices starting from the low hundreds and reaching even tens of thousands of dollars for just one tweet. </p>
<p>The term “shilling” refers to the undisclosed advertising of a project, with the goal of increasing its visibility and convincing the followers of the shiller to invest in it. The practice has become increasingly popular, considering that it is a fairly low-effort job but a highly profitiable one. And it is also remunerative for the projects, which most of the times are scams and rug pulls looking to attract liquidity, something they can find by relying on influencers with huge followings.</p>
<p>Although it is worth mentioning that not all projects that rely on unconventional means to advertise themselves have bad intentions: influencers are quickly becoming an essential part of marketing, not only in crypto but also in fashion, gaming, movies, and many other commercial sectors.</p>
<p>That is why it is always recommended to do your own research when it comes to investing, be it an advertised project from your favourite influencer, or a gem that you found by yourself!</p>
<h3 id="h3-Tesla20gaat20investeren20in20BTCmijnfaciliteit2020202012020181567"><a name="Tesla gaat investeren in BTC-mijnfaciliteit |   1  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tesla gaat investeren in BTC-mijnfaciliteit | <a href="https://www.independent.co.uk/tech/tesla-[Bitcoin](https://www.gate.io/trade/BTC_USDT" target="_blank">1</a> |</h3><p>Een van de meest populaire zorgen over cryptocurrencies is de hoeveelheid energie die nodig is om een nieuwe eenheid van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> te delven. of andere virtuele valuta die volgens de Cambridge <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Uit de elektriciteitsverbruiksindex blijkt dat Satoshi’s mijnbouw evenveel energie vergt als de hoeveelheid die Egypte in een jaar gebruikt. </p>
<p>De mijnbouwactiviteit is de belangrijkste reden waarom veel activisten onmiddellijk kritiek hebben op de ontwikkelingen en het nut van cryptocurrency, en de projecten ervan beschuldigen het milieu nauwelijks te schaden.</p>
<p>De meest populaire oplossing is die waarbij projecten zoals Ethereum, die momenteel afhankelijk zijn van PoW-verificatie transacties, zouden overschakelen op een meer milieuvriendelijke mijnbouwactiviteit, genaamd PoS. Ook al vergt de omschakeling meer tijd dan verwacht, zowel vanuit technologisch als vanuit veiligheidsoogpunt, toch zou de omschakeling de mijnbouwactiviteit een vermindering van de energiebehoefte garanderen.</p>
<p>Een andere oplossing die momenteel wordt getest is de oplossing die gericht is op duurzame energiebronnen zoals wind, waterkracht of zonne-energie, die al door Tesla is omarmd. De fabrikant van elektrische auto’s werkt samen met Block en Blockstream aan de bouw van een installatie van 3,8 megawatt die later dit jaar in bedrijf zal worden genomen.</p>
<p>Tesla en Megapack hebben al zonnepanelen en batterijen naar Texas gestuurd om te beginnen met het hele project dat tot doel heeft [Bitcoin] te delven (<a href="https://www.gate.io/trade/BTC_USDT" rel="nofollow noopener noreferrer" target="_blank">https://www.gate.io/trade/BTC_USDT</a>) met 100% hernieuwbare energie. Een initiatief dat de bekendheid van crypto over de hele wereld positief kan verbeteren, waardoor het slechte imago waar de sector momenteel vooral last van heeft, verbetert.</p>
<hr>
<h3 id="h3-Sponsor2020Linear20Finance320334"><a name="Sponsor | Linear Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sponsor | Linear Finance</h3><p>Before I continue with today’s Deep Dive, I must tell you about today’s sponsor. </p>
<p>Linear Finance is a distributed protocol that is compatible with multiple chains and majors with synthetic assets. One of the ways the project achieves this is by enabling investors to save on transaction fees and reduce the time it takes to bring an investment position to life.</p>
<p>The project’s white paper stresses delta-one and synthetic assets. In derivatives, delta-one means that a change in the price of the underlying asset ignites the same change to the product. Synthetic, on the other hand, are assets that derive their value from other assets. Examples of synthetics include futures and options. In the crypto world, synthetic assets enable investors to interact with cryptocurrencies without necessarily holding them.</p>
<p>These assets are also known as liquids because they can easily be converted to cash. The Linear protocol supports liquids in cryptocurrencies, crude oil, coffee, market indices, e-sports, among others.</p>
<p>The project is led by Drey Ng and Kevin Tai. Drey has an MS in Computer Science from the University of Hong Kong, while Kevin has a Harvard Business School MBA; both founders have worked extensively in tech and finance, with Drey currently serving as CPO at Liquefy and Kevin whose past roles include being vice president of structured products at Credit Suisse.</p>
<p>Linear is governed by the LinearDAO. It’s responsible for handling essential platform designs, as well as  parameters like $LINA rewards and frequency, pledge ratio, the introduction of new functionality, technology roadmap, and split of transaction fees.</p>
<p>Now to its tokenomics, the $LINA token is used on the network to back collateralized debts, as well as physical and digital assets. Holders of the token can access Linear USD (LUSD) which can be used to interact with Linear liquids on the Linear exchange. Additionally, token holders contribute to governance decisions such as which assets to be listed, and distribution models.</p>
<p>Be sure to check out the deion below because we’re giving away 59,000 $LINA tokens via airdrops between April 21st to the 28th. If you happen to win, the first thing you should do is to uate Linear’s staking mechanism. Of course, this isn’t financial advice and you’re free to do as you will.</p>
<p>But just to give you some ideas, $LINA stakers earn rewards on either pro-rata exchange fees or an inflationary reward basis. For the first option, the rewards are attained on a weekly basis, and the calculation is done while considering the stakers’ pledge ratio. Other ways stakers earn rewards are via yield farming, a positive variation of the pledge ratio, and providing liquidity on the Linear pool.</p>
<hr>
<h3 id="h3-DD2020Welke20producten20bouwen20technische20bedrijven20voor20de20Web3revolutie2020202012020202020220202020203202020202042020392244"><a name="DD | Welke producten bouwen technische bedrijven voor de Web3-revolutie? |   1  |   2  |   3  |   4  |" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DD | Welke producten bouwen technische bedrijven voor de Web3-revolutie? | <a href="https://www.gate.io/blog_detail/814/Snapchat-And-Metaversehttp://" target="_blank">1</a> | <a href="https://www.gate.io/blog_detail/832/Adobe-s-Plans-For-the-Metaversehttp://" target="_blank">2</a> | <a href="https://www.gate.io/blog_detail/824/Amazon-hits-the-Metaverse-with-a-3D-gamehttp://" target="_blank">3</a> | <a href="https://www.gate.io/blog_detail/852/How-Most-Web2-Companies-Are-Adopting-The-Web3-Technologyhttp://" target="_blank">4</a> |</h3><p>De opkomst van de Web3-revolutie<br>Met de toenemende populariteit van Web3 hebben veel bedrijven zich op de nieuwe markt begeven in de hoop hun diensten te verbeteren, hun gemeenschap toegang te geven tot nieuwe functionaliteiten en tegelijkertijd de inkomsten van hun merk te verhogen.</p>
<p>Het internet blijft zich ontwikkelen en werd aanvankelijk alleen gebruikt als informatiebron, maar is nu het belangrijkste instrument voor mensen om met elkaar te communiceren. De huidige economie en de meeste van onze dagelijkse interacties berusten op virtuele communicatie en daarom zijn sociale netwerken en veel digitale bedrijven steeds populairder geworden. </p>
<p>Zoals in alle sectoren is de concurrentie echter hevig, en bedrijven zijn voortdurend op zoek naar de nieuwste, allernieuwste technologieën waarmee zij hun activiteiten kunnen uitbreiden en een voorsprong kunnen nemen op hun concurrenten. </p>
<p>Een van deze technologieën, waarin bedrijven de afgelopen jaren aanzienlijke hoeveelheden kapitaal zijn gaan investeren, is Web3.</p>
<p>Wat vooral de aandacht van grote bedrijven heeft getrokken, is het potentieel dat Web3 kan bieden, om een volledig digitale wereld te creëren die lijkt op de echte, waarin goederen en diensten kunnen worden verkocht aan de mensen die virtuele burgers zijn geworden.</p>
<p>Sociale netwerkplatforms, bekende merken, grote korpsen en bedrijfsorganisaties gaan verschillende partnerschappen en samenwerkingsverbanden aan om persoonlijke projecten te lanceren die op de blockchaintechnologie zijn gebouwd.<br>Web2 wordt gecontroleerd door merken en technologiebedrijven die hun autoriteit nog verder willen uitbreiden, daarom hebben zij al verschillende strategieën gepland met betrekking tot de volgende internetrevolutie. Sommigen financieren kleinere vestigingen binnen de bedrijven, terwijl anderen investeren in start-ups in de hoop de verborgen parel te vinden.</p>
<p>Amazon’s Metaverse 3D Game<br>Amazon, een van de grootste e-commercebedrijven die er zijn, heeft onlangs zijn eigen 3D-game in de metaverse gelanceerd: het heeft een interactieve, economische en verkoopbenadering, gericht op het onderwijzen van studenten over cloud computing. Het spel, genaamd AWS Cloud Question, geeft de gebruiker de mogelijkheid om door een virtuele stad te lopen waar ze de bewoners moeten helpen bij het oplossen van cloud-gerelateerde IT-problemen. Naast het educatieve gedeelte moedigt het platform gebruikers aan om het spel te spelen door hen ook in staat te stellen verschillende in-game activa vrij te spelen, wat een vrij vergelijkbare benadering is als de huidige videogame-industrie.</p>
<p>Snapchat springt in het Web3: Bitmoji-service &amp; AR-bril<br>Snapchat heeft onlangs geïnvesteerd in de AR-technologie die de Metaverse-integratie binnen de app vorm moet geven. Het plan is om de gebruikers de mogelijkheid te bieden creaties te realiseren die de gemeenschap helpen de digitale wereld te ervaren en ten volle te beleven.<br>Sinds de lancering van het project zijn ongeveer 300 van deze AR-effecten meer dan 1 miljard keer bekeken. </p>
<p>Toch droomt Snapchat nog groter en daarom heeft het mensen de mogelijkheid gegeven hun eigen virtuele mensen te creëren en te personaliseren via de Bitmoji-dienst, waarmee het duidelijk overschakelt van een 2D-personage naar een 3D-personage.</p>
<p>Het bedrijf heeft ook de AR-bril gecreëerd waarmee mensen digitale objecten in de echte wereld kunnen projecteren, waardoor mensen een nieuw leven kunnen leiden dat wordt gekenmerkt door virtuele hulpmiddelen binnen hun eigen persoonlijke leven.</p>
<p>Adobe’s Softwares Are Shaping Metaverse’s AR<br>Zelfs Adobe, de techgigant, heeft in maart aangekondigd dat het bedrijf zich richt op het maken van een whitepaper over zijn plan om toe te treden tot de Metaverse-realiteit. Het hoofddoel is het leveren van AR/VR-diensten en het creëren van 3D-inhoud, wat betekent dat het bedrijf kijkt naar het bouwen van een soort creatieve hulp voor andere merken. </p>
<p>Met Substance 3D, een van de diensten van Adobe, kunnen mensen 3D-kunst ontwerpen en deze via AR-technologie tot leven brengen. Anderzijds biedt Aero, een andere innovatieve software, gebruikers de mogelijkheid om snel virtuele objecten te creëren en te delen via smartphone of tablet.</p>
<p>Conclusie<br>Er zijn talloze andere voorbeelden van grote bedrijven, waarvan sommige niet eens actief zijn in de technologie-industrie, die een nieuwe inkomstenstroom nastreven door zich in de Web3-ruimte te begeven. Of deze inspanningen vruchten zullen afwerpen, zal alleen de tijd leren: aangezien Web3 een relatief nieuwe sector is, staan radicale innovaties en veranderingen altijd voor de deur, wat de dorst naar innovatie alleen maar kan aanwakkeren en de concurrentie nog heviger kan maken.</p>