V29ybGRjb2luIEV2b2x1ZWVydCB0b3QgJ1dvcmxkJyBtZXQgTGFuY2VyaW5nIHZhbiBXb3JsZCBDaGFpbiAmIEdlYXZhbmNlZXJkZSBJRA==

2024-10-31, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/17303453501692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR186831"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De drie pijlers van World Network (World) zijn World Chain, World ID en Worldcoin (WLD).</p>
<p>In een poging om meer producten aan zijn gebruikers aan te bieden heeft World Network zijn infrastructuur en producten verbeterd.</p>
<p>World ID Deep Face is een functie die de wereld zal helpen in de strijd tegen diepe nepbeelden.</p>
<h2 id="h2-Kennismaking821621"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>In het recente verleden hebben verschillende blockchainprojecten zich opnieuw gepositioneerd om nieuwe functies op te nemen en hun visies uit te breiden. Anderen hebben zich opnieuw gepositioneerd na het vormen van allianties en partnerschappen. Aan de andere kant moesten sommige cryptoprojecten die ondermaats presteerden zich opnieuw positioneren op de markt om hun gebruikersbestanden uit te breiden of meer inkomsten te genereren voor ontwikkelingsdoeleinden. Vandaag kijken we naar de rebranding van WorldCoin naar World Network.</p>
<h2 id="h2-Introductie20van20World20Chain20en20World20ID2030831040"><a name="Introductie van World Chain en World ID 3.0." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie van World Chain en World ID 3.0.</h2><p>Alex Blania en Sam Altman, mede-uitvinders van Worldcoin, gaven wat updates over het project dat ze 5 jaar geleden hebben gelanceerd. Eigenlijk, <a href="https://www.gate.io/learn/articles/what-is-worldcoin-and-how-does-it-work/639" target="_blank">WorldCoin, nu bekend als World Network</a> zal maatregelen introduceren die de infrastructuur en schaal van haar activiteiten zullen verbeteren. De oprichters willen ervoor zorgen dat de diensten en producten van World beschikbaar zullen zijn voor alle geschikte mensen over de hele wereld. De drie pijlers van World Network (World) zijn World Chain, World ID en <a href="https://www.gate.io/price/worldcoin-wdc" target="_blank">Worldcoin</a>. In feite heeft World Network als doel een netwerk van geverifieerde mensen te creëren, zodat ze hun beveiliging vergroten wanneer ze communiceren met door AI aangedreven producten.</p>
<h2 id="h2-Overgang20van20WorldCoin20naar20World20Network20Visie20en20Missie227886"><a name="Overgang van WorldCoin naar World Network: Visie en Missie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overgang van WorldCoin naar World Network: Visie en Missie</h2><p>World Network, een digitaal project dat irisscan-technologie gebruikt om een virtuele identiteit voor mensen te creëren, wordt om verschillende redenen opnieuw gelanceerd. De visie van World is geëvolueerd, van alleen maar gericht zijn op het leveren van bewijs van menselijkheid naar het streven naar een meer gedecentraliseerd netwerk met een breder productaanbod. Bovendien streeft het ernaar om meer verbeterde producten en diensten dan ooit tevoren te ontketenen. Vanaf 17 oktober zijn meer dan 15 miljoen gebruikers gemigreerd naar World Chain.</p>
<p>Volgens Blania en Altman omvat de naam WorldCoin niet langer de missie van het project, wat heeft geleid tot de herpositionering als ‘World’. Het bedrijf heeft meer details over deze ontwikkeling gegeven op zijn website. Het <a href="https://world.org/blog/announcements/hello-world-5-key-announcements-from-new-world-event-san-francisco" rel="nofollow noopener noreferrer" target="_blank">uitgelegd</a>: De naam ‘Worldcoin’ omvat niet langer de missie van het project - om elke mens te versnellen … World is echt een netwerk van echte, geverifieerde mensen dat is opgebouwd om een optimistische toekomst mogelijk te maken waarin mensen centraal blijven staan in de vooruitgang van AI.</p>
<p>WorldCoin is niet het enige crypto-project dat de afgelopen maanden een herbranding heeft ondergaan. MakerDao heeft zichzelf omgedoopt tot Sky terwijl <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> wordt nu Sonic genoemd. Nog opvallender, <a href="https://www.gate.io/how-to-buy/singularitynet-agix" target="_blank">SingularityNET</a>, FET en <a href="https://www.gate.io/price-prediction/ocean-protocol-ocean" target="_blank">Ocean Protocol</a> hebben zich samengevoegd tot vormen <a href="https://www.gate.io/price/artificial-superintelligence-alliance-fet" target="_blank">Kunstmatige Superintelligentie Alliantie</a>- een partnerschap van AI-projecten. Ook hebben SingularityDAO, Cogito Finance en SelfKey zich verenigd om Singularity Finance (SFI) te vormen.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/worldcoin-wld" target="_blank">Worldcoin prijsvoorspelling &amp; voorspelling voor 2025, 2030</a></p>
<h2 id="h2-Nieuwe20generatie20Orbapparaten20en20hun20verbeterde20prestaties960910"><a name="Nieuwe generatie Orb-apparaten en hun verbeterde prestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe generatie Orb-apparaten en hun verbeterde prestaties</h2><p>Als onderdeel van de rebranding heeft World Network een orb-apparaatupgrade gelanceerd waarmee het proces van menselijke verificatie schaalbaarder, efficiënter en sneller is dan voorheen. Het nieuwe orb-apparaat maakt gebruik van de NVIDIA Jetson-chipset die vijf keer sneller is dan de vorige. Orb-apparaten worden ook vergezeld door meer geavanceerde hardware- en softwareverbeteringen. Bovendien heeft het een verwijderbare externe SD-kaart. Die upgrade gaat gepaard met functies en diensten zoals vlaggenschiplocaties, self-service Orb-kiosken en on-demand Orbs.</p>
<p>Deze Orb-apparaatupgrade zal het World Network in staat stellen om zijn diensten uit te breiden naar alle hoeken van de wereld. Aangezien de verbeterde orb goedkoper en sneller te ontwikkelen is, zal World Network zijn productie uitbreiden om te voorzien in de behoeften van alle mensen die de apparaten nodig hebben. Op dit moment heeft World Network als doel zijn producten te lanceren in verschillende landen en steden, waaronder Buenos Aires en Mexico-Stad. Vervolgens zullen de verbeterde orbs beschikbaar zijn in cafés en ook op verzoek worden bezorgd. De nieuwe orb zal echter pas in het voorjaar van 2025 worden verspreid.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-world-mobile-token-all-you-need-to-know-about-wmt/1890" target="_blank">Wat is World Mobile Token? Alles wat u moet weten over WMT</a></p>
<h2 id="h2-World20Chain20Mainnet20Lancering742587"><a name="World Chain Mainnet Lancering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>World Chain Mainnet Lancering</h2><p>Naast de upgrade van zijn bolvormige apparaat heeft World Network World Chain gelanceerd, een <a href="https://www.gate.io/learn/articles/what-is-layer-2/55" target="_blank">Laag 2</a> blockchain gebaseerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk. De lancering van World Chain vond plaats op 17 oktober en het heeft meer dan 7 miljoen geverifieerde gebruikers aan boord gebracht. Op dit moment is het de grootste blockchain die gedecentraliseerde menselijke verificatiediensten biedt. World Network wordt ondersteund door veel blockchain serviceproviders en gerelateerde toepassingen, waaronder <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, Alchemy, Dune, Etherscan, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, en veilig.</p>
<h2 id="h2-World20Network20richt20zich20op20menselijke20veiligheid20met20World20ID2030418533"><a name="World Network richt zich op menselijke veiligheid met World ID 3.0" class="reference-link"></a><span class="header-link octicon octicon-link"></span>World Network richt zich op menselijke veiligheid met World ID 3.0</h2><p>Een van de belangrijkste kenmerken die World Network heeft geïntroduceerd in zijn nieuwste stap is World ID 3.0. Met deze functie zullen veel mensen over de hele wereld de mogelijkheid hebben om hun digitale identiteiten te verifiëren met behulp van het Orb-apparaat. Ook zal deze functie <a href="https://www.gate.io/how-to-buy/world-id-woid" target="_blank">World ID-houders inschakelen</a> om relevante persoonlijke informatie van hun fysieke NFC-geactiveerde paspoorten op hun World App op te slaan. Als gevolg hiervan kunnen gebruikers hun World ID gebruiken om hun persoonlijke gegevens zoals nationaliteit en leeftijd te bewijzen.</p>
<p>Interessant genoeg heeft World ID 3.0 een andere unieke functie, Mini-Apps genaamd, waarmee gebruikers andere toepassingen kunnen integreren om binnen de World App te draaien. Dergelijke toepassingen worden gekoppeld aan de World ID, Contacten en Wallet van een individu. Bovendien heeft het verbeterde beveiligings- en communityfuncties. Met deze ontwikkelingen is World Network geëvolueerd tot een echt op de mens gerichte internetdienstverlener, omdat het mensen in staat stelt controle te hebben over hun identiteit en beveiliging in het licht van kunstmatige intelligentie en cyberdreigingen.</p>
<p>Belangrijker nog, vanwege de centrale rol die World ID 3.0 speelt in de blockchain van digitale identiteit, zal het gemakkelijker zijn om opkomende cybersecurity-bedreigingen zoals deepfakes te bestrijden. Belangrijker nog, World Network heeft de World ID Deep Face geïntroduceerd, een geavanceerde manier om deepfakes en andere online frauduleuze praktijken tegen te gaan. De World ID Deep Face is een technologie die persoonlijke gegevensbescherming, orb-beeldvorming en gezichtsverificatie combineert om gebruikers in staat te stellen te controleren of ze met echte mensen communiceren om deepfakes te voorkomen.</p>
<p>De World ID Deep Face kan worden geïntegreerd met de World App of worden geïnstalleerd op computers. Daarom kan het werken met verschillende videochatplatforms of videoconferentie-apps. Om naadloze native integratie mogelijk te maken, heeft de World ID Deep Face-app een SDK waarmee het effectief deepfakes kan detecteren. Zo ontwikkelt het World Network de technologie voor het voorkomen van crypto-fraude en de verificatie van menselijke transacties op de blockchain.</p>
<p>De dreiging van deepfakes neemt toe, aangezien sommige slechte actoren malware en bots ontwikkelen die deepfakes kunnen creëren. Deze trend is zichtbaar op verschillende socialemediaplatforms waar veel chatbots en botaccounts actief zijn. Bijvoorbeeld op datingsites maken sommige personen tientallen door bots beheerde accounts aan. Al met al zijn dergelijke praktijken gericht op het manipuleren van de waarheid voor politieke, sociale en zelfs economische doeleinden. Als voorbeeld, in de cryptosector gebruiken sommige personen of organisaties bots om handelsvolumes of prijzen van bepaalde activa te manipuleren.</p>
<h2 id="h2-WLD20Prijsbeweging20Voorspellingen20en20Dynamiek78632"><a name="WLD Prijsbeweging: Voorspellingen en Dynamiek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD Prijsbeweging: Voorspellingen en Dynamiek</h2><p>De inheemse cryptocurrency van World Network, WLD, heeft gemengde resultaten gezien. Desalniettemin beweegt het al geruime tijd zijwaarts. Het piekte in maart toen het op de 10e van de maand $12 bereikte. Op 7 juli was de prijs gedaald tot ongeveer $2. Sindsdien is het nooit volledig hersteld. De volgende grafiek <a href="https://www.gate.io/price/worldcoin-wld" target="_blank">toont WLD prijsbeweging</a> gedurende het afgelopen jaar.<br><img src="https://gimg2.gateimg.com/image/article/17303456801.jpeg" alt=""><br>WLD Prijsactie - CoinMarketCap</p>
<p>Zoals <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">de grafiek</a> zoals blijkt, ligt de wereldmunt prijs rond het laagste punt van het jaar. Dit komt doordat het aan het begin van het jaar werd verhandeld voor ongeveer $3,60. Op dit moment kopen mensen WLD voor $1,99. Het is al in een dalende trend omdat de waarde in de afgelopen 24 uur met 6,84% is gedaald. De prijsgrafiek van de afgelopen 7 dagen laat zien dat WLD zich binnen een dalend kanaal bevindt.<br><img src="https://gimg2.gateimg.com/image/article/17303456992.jpeg" alt=""><br>WLD Wekelijkse Prijsgrafiek - CoinMarketCap</p>
<p>Op de maandelijkse prijsgrafiek bevindt de WLD-prijs zich binnen een horizontaal kanaal tussen $1,70 en $2,41. Als de prijs onder het kanaal uitbreekt, kan deze dalen naar $1,55. Desalniettemin, als het boven het kanaal uitbreekt, kan het stijgen naar $2,45. Als de koopdruk toeneemt, kan de waarde ervan $5,74 bereiken, zijn hoogste punt in 7 maanden, bereikt op 29 april.</p>
<h2 id="h2-Conclusie397719"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>World Network, voorheen WorldCoin genoemd, heeft veel veranderingen doorgevoerd om zichzelf te herpositioneren als een toonaangevende digitale identiteitsblockchain. Het lanceerde zijn blockchain, World Chain, in oktober. Het doel van dit netwerk is om de dienst bewijs van menselijkheid beschikbaar te stellen voor alle in aanmerking komende mensen over de hele wereld. Binnenkort zal het een geüpgraded Orb-apparaat en World ID 3.0 lanceren.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat 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>