RGUgdmVyc2NoaWxsZW5kZSBzb29ydGVuIE5GVCdz

2023-01-12, 10:03

<p><img src="https://gimg2.gateimg.com/image/article/167351965620230112-183345.jpeg" alt=""><br>Non-fungible tokens (NFT’s) hebben de afgelopen jaren een snelle opkomst in populariteit meegemaakt, van een relatief nichegebied van de cryptowereld tot een breed erkend concept. Veel mensen kunnen <a href="https://www.gate.io/nft/?ch=GM_blog_nft_20230112&amp;utm_campaign=TR_z1upQ37n&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">NFTs</a> met unieke digitale kunstwerken, maar nu zijn er verschillende NFT’s beschikbaar nu de markt is uitgegroeid tot een industrie van meerdere miljarden dollars. <a href="https://www.gate.io/nft/?ch=GM_blog_nft_20230112&amp;utm_campaign=TR_z1upQ37n&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">NFTs</a> kan worden gebruikt om eigendom van fysieke of digitale activa zoals kunst, muziek, afbeeldingen en verzamelobjecten te bewijzen, maar ze worden ook gebruikt in verschillende andere sectoren, waaronder mode en gaming. In dit artikel zullen we nauw kijken naar verschillende soorten NFT’s en hoe ze worden gebruikt.</p>
<h2 id="h2-PFP20NFTs696482"><a name="PFP NFTs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PFP NFTs</h2><p>PFP NFT’s, of profielfoto NFT’s, zijn digitale avatars die vaak worden gebruikt als profielfoto van een persoon op sociale media zoals Twitter. Een van de eerste PFP NFT’s was CryptoPunks, gemaakt in 2017 door Larva Labs, dat bestond uit 10.000 algorithmisch gegenereerde punks met verschillende eigenschappen. Een andere opmerkelijke PFP NFT is de Bored Ape Yacht Club (BAYC), gemaakt door Yuga Labs in april 2021. Het duurste BAYC NFT werd verkocht voor 3,4 miljoen dollar. Het belangrijkste voordeel van het bezitten van een PFP NFT is toegang tot exclusieve NFT-gemeenschappen en toekomstige voordelen zoals airdrops of andere beloningen. Bijvoorbeeld, het bezitten van een Bored Ape NFT zou je in staat stellen om lid te worden van een elitegroep mensen, waaronder beroemdheden als Jimmy Fallon, Madonna en Paris Hilton, en zelfs deel te nemen aan evenementen in de echte wereld zoals ApeFest en andere evenementen die alleen toegankelijk zijn voor NFT-houders. Naarmate het metaversum zich blijft ontwikkelen, wordt verwacht dat PFP NFT’s steeds vaker zullen worden gebruikt als avatars in deze virtuele ecoen.</p>
<h2 id="h2-Generatieve20kunst188731"><a name="Generatieve kunst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Generatieve kunst</h2><p>Generatieve kunst NFT’s zijn digitale kunstwerken die zijn gemaakt met behulp van robots en AI-tools die teruggaan tot de jaren 1960. Deze werken hebben een gemeenschappelijke uitstraling, maar zijn uniek en gemaakt door een algoritme met ingebakken willekeurigheid. Art Blocks is een speciaal platform dat generatieve kunstenaars begeleidt bij het proces van het maken en verkopen van hun werk. Andere leiders op het gebied van generatieve kunst NFT’s zijn projecten zoals Autoglyphs van Larva Labs, Lost Poets en Ringers, evenals kunstenaars Tyler Hobbs, Robbie Barret en Matt Kane.</p>
<h2 id="h2-Muziek20NFTs505762"><a name="Muziek NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Muziek NFT’s</h2><p>Muziek NFT’s kunnen worden gebruikt om een bestand van een nummer of album te bezitten. In plaats van een licentie te kopen om naar een nummer te luisteren, geeft het kopen van een muziek-NFT eigendom van het bestand. Hierdoor kunnen fans investeren in het werk van hun favoriete artiest en er een stuk van bezitten. Artiesten kunnen muziek-NFT’s ook gebruiken om met hun fans in contact te komen en beloningen aan te bieden zoals nieuwe muziek, exclusieve merchandise, ervaringen en concertkaartjes. Er zijn ook specifieke projecten met parameters die NFT-eigenaren royalty’s geven op streamingrechten of eigendom van een stuk van het nummer genaamd Limited Digital Assets of LDA’s. Limited Digital Assets (LDA’s) werden voor het eerst geïntroduceerd door Royal, een platform voor het maken van royalty-dragende NFT’s. De eerste LDA op het platform was het nummer “Worst Case” van artiest 3LAU.<br>Dit zijn slechts enkele voorbeelden van de verschillende soorten NFT’s die beschikbaar zijn. Naarmate de markt zich blijft ontwikkelen, kunnen we verwachten dat nieuwe en unieke vormen van NFT’s worden ontwikkeld en op nieuwe en opwindende manieren worden gebruikt.</p>
<h2 id="h2-Onroerend20goed524718"><a name="Onroerend goed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onroerend goed</h2><p>Real estate NFT’s zijn digitale representaties van onroerend goed zoals percelen grond of virtuele gebouwen. Deze NFT’s kunnen worden gebruikt om eigendom en handel van virtueel onroerend goed in online games of virtuele werelden te vertegenwoordigen. Het stelt ook investeerders in staat om te investeren in virtueel onroerend goed als een alternatieve of aanvullende manier van traditionele investeringen.</p>
<h2 id="h2-Mode20NFTs197510"><a name="Mode NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mode NFT’s</h2><p>Fashion NFT’s zijn digitale activa die virtuele of fysieke modeartikelen vertegenwoordigen. Ze kunnen worden gebruikt om eigendom en herkomst van luxe goederen weer te geven en ook om toegang tot de evenementen en ontwerperscollecties in de mode-industrie weer te geven. Balmain presenteerde de allereerste virtuele fashion NFT-collectie tijdens Paris Fashion Week 2020, en later begonnen meer merken zoals Gucci en Prada te experimenteren met de technologie.</p>
<p>Tommy Hilfiger, Dolce &amp; Gabbana en Nike hebben ook digitale-kleding-only collecties uitgebracht als NFT’s. Deze digitale kleding kan worden gedragen door avatars in virtuele werelden zoals Decentraland. Bovendien stellen platforms zoals The Dematerialised (DMAT) gebruikers in staat om NFT-kledingstijlen op het platform te kopen, verkopen en virtueel te passen.</p>
<h2 id="h2-Playtoearn20gaming20NFTs566341"><a name="Play-to-earn gaming NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Play-to-earn gaming NFT’s</h2><p>Gaming NFT’s zijn digitale activa die in-game items, wapens, avatars of andere virtuele goederen vertegenwoordigen. Deze NFT’s stellen spelers in staat om unieke en zeldzame in-game items te bezitten en kunnen ook worden gebruikt om toegang tot bepaalde functies en ervaringen in het spel te vertegenwoordigen.</p>
<p>Enkele populaire voorbeelden van spellen die NFT’s gebruiken zijn <a href="/price/axie-infinity-axs" target="_blank" class="blog_inner_link">Axie Infinity</a> en Gods Unchained, die spelers eigendom geven over hun beloningen en de mogelijkheid om hun in-game bezittingen te verkopen en verhandelen. Dit kan in-game cryptovaluta-beloningen omvatten, evenals de NFT’s zelf, zoals de ‘Axies’, die de in-game virtuele huisdieren zijn die centraal staan in de gameplay op Axie Infinity, of de structuur NFT’s in Star Atlas, een metaverse-platform. In Star Atlas kunnen spelers in-game tokens zoals ATLAS en POLIS verdienen door missies te voltooien, en een scala aan NFT’s kan worden gekocht en verhandeld op de NFT-marktplaats van het spel. Naarmate steeds meer spellen blockchain-technologie opnemen, groeit het gebruik van gaming NFT’s snel.</p>
<h2 id="h2-Nut20NFTs915243"><a name="Nut NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nut NFT’s</h2><p>Utility NFT’s zijn digitale activa die worden gebruikt om toegang tot een bepaalde dienst of product te vertegenwoordigen. Ze kunnen worden gebruikt als bewijs van eigendom, toegang of lidmaatschap van een dienst. Utility NFT’s kunnen ook toegang tot virtuele evenementen, online platforms en lidmaatschappen in online gemeenschappen vertegenwoordigen.</p>
<p>Video-NFT’s</p>
<p>Een ander type NFT zijn Video NFT’s, die unieke digitale activa zijn die eigendom vertegenwoordigen van een videobestand of een videostream. Deze NFT’s kunnen worden gebruikt om eigendom van een film, een muziekvideo of andere vormen van videomateriaal te vertegenwoordigen. Ze kunnen ook worden gebruikt om toegang tot exclusieve videocontent of virtuele evenementen te vertegenwoordigen. Naarmate het gebruik van online streamingplatforms blijft groeien, zal het gebruik van video NFT’s als een vorm van monetisatie en als een manier om exclusieve toegang tot inhoud te bieden waarschijnlijk toenemen.</p>
<p>Een ander type NFT is de VR NFT. Deze NFT’s kunnen toegang tot een virtuele wereld, virtueel onroerend goed of een virtuele ervaring vertegenwoordigen. Ze stellen makers in staat om hun virtuele ervaringen te gelde te maken en geven gebruikers eigendom van hun virtuele ruimte en ervaringen.</p>
<h2 id="h2-Liefdadigheids20NFTs694982"><a name="Liefdadigheids NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Liefdadigheids NFT’s</h2><p>Daarnaast is er een groeiend gebruik van NFT’s voor liefdadigheid en sociale impact. Dit zijn NFT’s die worden gebruikt om het eigendom van een sociaal goed weer te geven, zoals een boom die in een bos wordt geplant of een deel van een gemeenschapsproject. Deze NFT’s kunnen worden gebruikt om geld in te zamelen voor een sociaal doel en om een transparante en verifieerbare manier te creëren om de voortgang van het project te volgen.</p>
<p>Over het algemeen zijn NFT’s een veelzijdige technologie die het mogelijk maakt om unieke digitale bezittingen te creëren en te bezitten. Elk type NFT heeft een speciaal doel en opent nieuwe mogelijkheden voor makers, verzamelaars en investeerders. Ze kunnen vele vormen aannemen, zoals kunst, verzamelobjecten, in-game items, onroerend goed, muziek, beroemdheid bezittingen, mode, gaming en nutsvoorzieningen. Hierdoor ontstaan nieuwe mogelijkheden voor makers, verzamelaars en investeerders, en de potentieel gebruiksscenario’s blijven groeien. Naarmate technologie en infrastructuur blijven evolueren, verwachten we nieuwe en innovatieve toepassingen van NFT’s in verschillende industrieën.</p>
<h4 id="h4-Auteur20Gate20NFT20team358607"><a name="Auteur: Gate NFT team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Auteur: Gate NFT team</h4><p>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie. Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io is vermeld. In alle glen zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.</p>