R2F0ZS5pbyBBTUEgbWV0IEZyZXNoQ3V0IC0gRWVuIG9wIGRlIGdlbWVlbnNjaGFwIGdlcmljaHQgZ2FtaW5nLWluaG91ZHBsYXRmb3Jt

<p><img src="https://gimg2.gateimg.com/image/article/16802467891.jpg" alt=""><br><strong>Tijd: 16 mei 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehouden met James Kuk, medeoprichter en CEO van FreshCut 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="http://diamond.freshcut.gg/" rel="nofollow noopener noreferrer" target="_blank">http://diamond.freshcut.gg/</a></strong><br><strong>Twitter: <a href="https://twitter.com/freshcut" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/freshcut</a></strong><br><strong>Volg FreshCut op <a href="https://twitter.com/freshcut" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16802470082.png" alt=""><br><strong>James Kuk — Medeoprichter en CEO van FreshCut</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio625332"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Q120Kunt20u20ons20vertellen20over20de20visie20achter20FreshCut20en20waarom20u20het20lanceert206229"><a name="Q1: Kunt u ons vertellen over de visie achter FreshCut en waarom u het lanceert?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u ons vertellen over de visie achter FreshCut en waarom u het lanceert?</h3><p><strong>James</strong>: Absoluut. Onze visie is om HET thuis te zijn voor kortdurende gaming content en waarde terug te geven aan makers en communityleden - een plek waar legacy web2 sociale platforms zoals TikTok en Instagram falen.</p>
<p>De wereldwijde gamingcontentcategorie groeit al 4 jaar meer dan 40% YoY en het segment van korte videoclips is ongelooflijk gefragmenteerd en onderbediend - gaming heeft wereldwijd meer dan 1 miljard fans die spelen en games bekijken en ze verdienen allemaal een betere ervaring en betere waarde.</p>
<p>FreshCut is een <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gaming community en content ecosysteem gebouwd voor makers en fans. Ons platform combineert korte gaming video’s en een community token, FreshCut Diamonds ($FCD), om maker-fan betrokkenheid opnieuw vorm te geven en top-level gaming ervaringen te tonen. FreshCut zal makers en fans belonen via create-and-earn en watch-and-earn mechanismen en geeft hen ook een stem op het platform.</p>
<h3 id="h3-Q220Kun20je20onze20gemeenschap20wat20meer20vertellen20over20het20FreshCutecosysteem944959"><a name="Q2: Kun je onze gemeenschap wat meer vertellen over het FreshCut-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je onze gemeenschap wat meer vertellen over het FreshCut-ecosysteem?</h3><p><strong>James</strong>: Ons ecosysteem omvat de FreshCut mobiele app (iOS en Android) voor optimaal kijken van korte gaming content, de $FCD token, onze web kijkervaring voor desktop, en onze gemeenschap van makers, fans, esports en game studio partners. We werken samen met enkele van de grootste gaming makers, waaronder Brycent, Chief Pat, Mystic7 en nog veel meer.</p>
<p>Op dit moment kunnen fans $FCD verdienen door deel te nemen aan onze Discord-community-evenementen. Later deze zomer kun je $FCD verdienen in de app door content te bekijken en quests te voltooien.</p>
<p>Dit zal een van de eerste gaming content apps zijn die wordt gelanceerd met een geïntegreerde token. Misschien heb je wel eens gehoord van apps zoals <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a> waar je kunt “lopen en verdienen” - we introduceren “kijken en verdienen” aan de wereld! Verdien $FCD door naar League of Legends hoogtepunten of grappige Fortnite mislukkingen te kijken - op FreshCut.</p>
<p>In de toekomst zullen we extra nut creëren voor $FCD door samen te werken met andere projecten in het web3-ecosysteem, ons lidmaatschapsprogramma uit te breiden waar $FCD-houders waardevolle beloningen en privileges krijgen, onze gemeenschapsevenementen zowel in IRL als online uit te breiden, en duurzame inkomstenstromen toe te voegen zoals reclame en NFT’s.</p>
<p>Het ecosysteem zal ook games en gamebedrijven bevatten waarmee we partnerschappen willen aangaan, wat de reden is waarom we strategische investeerders zoals Animoca, C2X (Com2Us) en hebben. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> - we zullen ernaar streven om hun spellen en onze makers en gemeenschappen samen te laten groeien.</p>
<p>Het FreshCut-ecosysteem wordt ondersteund door toonaangevende VC’s, strategische partners en operators, waaronder Galaxy Interactive, Animoca Brands, Republic Crypto en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>.</p>
<h3 id="h3-Q320Vertel20ons20alstublieft20over20het20team20achter20FreshCut20en20hoe20uw20ervaring20u20hier20heeft20gebracht821777"><a name="Q3: Vertel ons alstublieft over het team achter FreshCut, en hoe uw ervaring u hier heeft gebracht?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Vertel ons alstublieft over het team achter FreshCut, en hoe uw ervaring u hier heeft gebracht?</h3><p><strong>James</strong>: Mijn medeoprichters en ik komen van Twitch waar we het platform hebben laten groeien en schalen naar honderden miljoenen toegewijde fans en gemeenschapsleden. We hebben samengewerkt met enkele van de grootste makers, game-uitgevers en eSports-organisaties ter wereld, zoals Blizzard, Riot, Valve, Ubisoft, PUBG en anderen.</p>
<p>Ik ( <a href="https://twitter.com/JamesSKuk" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/JamesSKuk</a>) runde eerder wereldwijde business development en strategische partnerschappen bij Twitch, waarbij commerciële partnerschappen werden afgehandeld met al onze gamebedrijven, esports en platformpartners. Daarvoor was ik leider van het uitgeversteam van Xbox Studio’s, waar ik werkte met wereldwijde IP’s zoals Halo, Gears of War en Minecraft.</p>
<p>Mijn medeoprichter en chief content officer Ernie ( <a href="https://twitter.com/ErnestLe" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ErnestLe</a> ) was een van de vroegste content creators op Twitch en YouTube - hij hielp bij het opzetten van het Twitch Creator-programma - waarbij hun creator-community groeide tot meer dan 30.000 partners.</p>
<p>Mijn andere medeoprichter en chief product officer Ben ( <a href="https://twitter.com/ben_stueck" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ben_stueck</a> Ik heb gewerkt aan de creatietools die miljoenen Twitch-creators hebben gebruikt.</p>
<p>We realiseerden ons dat er geen thuis was voor korte vorm gaming content op het internet en wilden dat oplossen. We zagen ook dat traditionele web2 businessmodellen de makers, fans en gemeenschap niet belonen. Daarom hebben we FreshCut gebouwd. Vandaag zijn we een team van 25+ met ervaring van Twitch, Xbox, Microsoft, Reddit en andere toonaangevende bedrijven.</p>
<h3 id="h3-Q420Laten20we20het20nu20hebben20over20het20concurrentievoordeel20van20FreshCut20Wat20maakt20jou20anders20dan20andere20vergelijkbare20projecten920995"><a name="Q4: Laten we het nu hebben over het concurrentievoordeel van FreshCut. Wat maakt jou anders dan andere vergelijkbare projecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Laten we het nu hebben over het concurrentievoordeel van FreshCut. Wat maakt jou anders dan andere vergelijkbare projecten?</h3><p><strong>James</strong>: We zijn anders gebouwd.<br>Hier is een samenvatting:<br>1/ Toegewijde gaming content curatie &amp; service voor gaming fans<br>2/ Disruptieve en EERLIJKE waarde distributie naar makers en gemeenschap via $FCD<br>3/ Integratie van native token voor juiste beloningen en stimulansen, en belangrijker nog, leuk entertainment!<br>4/ Creator &amp; Game partnerschappen &amp; Creator Fund</p>
<p>1/ We denken dat FreshCut complementair is aan de streamingplatforms en meer concurrentie biedt met TikTok/IG die geen goede kijkervaring bieden voor game-inhoud. Het is moeilijk om je favoriete games, makers, etc. te vinden - GEEN van deze platforms richt zich op gaming zoals FreshCut.</p>
<p>2/ Web2-erfgoedcontentplatforms nemen het grootste deel van de winst weg bij de makers, variërend van 30-50%. Met FreshCut geven we makers 90% van de tips op het platform, waarbij 10% terugvloeit naar de community-schatkist. We richten ons op het bieden van gunstiger economische voorwaarden voor de gemeenschap.</p>
<p>3/ We bouwen een bloeiend ecosysteem rond $FCD - door het te integreren in onze app, onze gemeenschapsevenementen, en meer om de makers en fans te belonen die helpen het platform te bouwen.</p>
<p>4/We werken samen met de grootste namen in web3 gaming creators zoals Brycent, Chief Pat en Mystic7, evenals enkele bekende web2-streamers zoals JERICHO. Later deze zomer - en we zullen een belangrijke Creator Fund-initiatief lanceren om nieuwe en bestaande creators te ondersteunen en aan boord te brengen op FreshCut.</p>
<h3 id="h3-Q520We20zouden20ook20graag20wat20meer20horen20over20jullie20aankomende20roadmap20Welke20belangrijke20functies20zijn20jullie20aan20het20ontwikkelen946281"><a name="Q5: We zouden ook graag wat meer horen over jullie aankomende roadmap. Welke belangrijke functies zijn jullie aan het ontwikkelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: We zouden ook graag wat meer horen over jullie aankomende roadmap. Welke belangrijke functies zijn jullie aan het ontwikkelen?</h3><p><strong>James</strong>: Ten eerste zullen we deze zomer onze eigen portemonnee integreren in onze mobiele app, zodat gebruikers en makers $FCD kunnen verdienen binnen iOS/Android via de mechanismen create-and-earn en watch/engage-and-earn. Fans zullen $FCD kunnen verdienen door dagelijkse/wekelijkse opdrachten te voltooien, video’s van hun favoriete makers te bekijken en deel te nemen in de community. Je kunt beloond worden voor wat je al leuk vindt! Vergelijkbaar met een geweldig model vandaag - <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STAP</a>, een oefening om een NFT-spel te verdienen.</p>
<p>Deze zomer introduceren we ook ons ​​FreshCut-lidmaatschapsprogramma waar fans $FCD kunnen gebruiken om lidmaatschappen te kopen waarmee ze verschillende niveaus van toegang, voordelen en extraatjes krijgen. We laten ons inspireren door geweldige lidmaatschapsmodellen zoals de Bored Ape Yacht Club. We geloven in het belonen van onze vroege supporters.</p>
<p>We denken ook aan adverteren en het mogelijk maken voor makers om digitale verzamelobjecten (NFT’s) te ontwerpen, maken en verkopen als extra inkomstenstromen in de toekomst.</p>
<p>Vanuit een groeiperspectief begint alles met makers. We zijn gericht op het aan boord brengen van makers in 2022 en het meenemen van hun gemeenschappen van fans. We hebben een volledig blitzplan om makers aan boord te brengen na TGE en de rest van het jaar.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>