R2F0ZS5pbyBBTUEgbWV0IE5lYmxpbyAtIE9tIEJsb2NrY2hhaW4gRWVudm91ZGlnIHRlIE1ha2Vu

<p><img src="https://gimg2.gateimg.com/image/article/16741134421.jpeg" alt=""><br><strong>Tijd: 27 oktober 2022, 13:00 UTC</strong><br><strong>Gate.io organiseerde een AMA (Ask-Me-Anything) sessie met Nebl Techy, CTO van Neblio in de Gate.io Exchange Community.</strong><br><strong>Officiële website: <a href="https://nebl.io/" rel="nofollow noopener noreferrer" target="_blank">https://nebl.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/NeblioTeam/" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/NeblioTeam/</a></strong><br><strong>Volg Neblio op Twitter</strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16741136062.png" alt=""><br><strong>Nebl Techy — CTO van Neblio</strong></p>
<h2 id="h2-Vraag20en20Antwoord20van20Gateio56432"><a name="Vraag en Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en Antwoord van Gate.io</h2><h3 id="h3-V120Kun20je20ons20alsjeblieft20vertellen20wat20Neblio20is98747"><a name="V1: Kun je ons alsjeblieft vertellen wat Neblio is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kun je ons alsjeblieft vertellen wat Neblio is?</h3><p><strong>Neblio</strong> (ticker $NEBL) is een open-source, gedecentraliseerd en veilig blockchain-platform gebouwd voor een breed scala aan enterprise-level applicaties en diensten. Neblio heeft zijn eigen blockchain en is een fork van. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>; het is Proof of Stake: stakers kunnen staken om deel te nemen aan de stemming over nieuwe initiatieven via NIP’s (Neblio Improvement Proposals).<br>Enkele van de gebruiksmogelijkheden van Neblio zijn Records Management, Supply chain, identity management en nog veel meer. Via API SDK’s in verschillende programmeertalen bieden wij eenvoudige integratie voor blockchain technologie.<br><img src="https://gimg2.gateimg.com/image/article/16741135923.png" alt=""><br>Neblio is beschikbaar op Gate.io en ook op andere topbeurzen zoals Binance.</p>
<h3 id="h3-Q220Neblio20heeft20zijn20routekaart20voor20de20rest20van20202220en20202320uitgegeven20Laat20ons20er20meer20over20weten918948"><a name="Q2: Neblio heeft zijn routekaart voor de rest van 2022 en 2023 uitgegeven. Laat ons er meer over weten." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Neblio heeft zijn routekaart voor de rest van 2022 en 2023 uitgegeven. Laat ons er meer over weten.</h3><p>Ja, het is vorige maand uitgegeven en met de input van onze geweldige community!<br>Laten we nu de belangrijkste punten van onze nieuwe routekaart doornemen:<br>Electrum-servers zijn geüpgraded en we hebben al onze eerste 2 bruggen gelanceerd en uitgebracht, naar de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Keten en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchains. De Ethereum-brug werd goedgekeurd via NIP, onze voorstelmethode, dus we raadplegen actief onze gemeenschap.<br>We zijn genoteerd op Gate.io, evenals op andere beurzen waar we meerdere paar vermeldingen en meerdere lopende c hebben gekregen <a href="/price/amp-amp" rel="nofollow noopener noreferrer" target="_blank">Amp</a> campagnes, d.w.z. voor handel en staking.<br>Onlangs hebben we ook een verzoek ingediend bij onze gemeenschap voor een nieuwe verkenner voor Neblio!<br>We zijn van plan de komende maanden te besteden aan het versterken van partnerschappen naast de vele die we tot nu toe hebben gehad, d.w.z. met Auction, Linear Finance en C98, de adoptie te vergroten, uit te breiden naar nieuwe markten, EVM-compatibele cross-chain functies zullen elk Neblio-token toestaan om te worden uitgegeven op de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> en ERC20-netwerken, nieuwe programma’s voor bug bounties, ecosysteemfonds, een lanceerplatform en uiteindelijk volledige EVM-cross-chain-compatibiliteit via slimme contracten.</p>
<h3 id="h3-Q320Waar20ben20je20nu20nog20meer20aan20het20werken174864"><a name="Q3: Waar ben je nu nog meer aan het werken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Waar ben je nu nog meer aan het werken?</h3><p>We zijn momenteel bezig met het creëren van een lanceerplatform waarmee blockchain-teams en -bedrijven in de beginfase geld kunnen inzamelen en hun projecten kunnen lanceren. We werken samen met een van de meest prominente blockchain-initiatieven om dit mogelijk te maken, en zelfs als er nog geen ETA is, denken we dat deze snel klaar zal zijn.<br>Neblio is de afgelopen maanden opmerkelijk snel gegroeid. Onze gemeenschap groeit non-stop nadat we meerdere regionale gemeenschappen hebben uitgebracht, waaronder de Chinese (@neblio_chinese) en Turkse (@neblio_turkish) gemeenschappen.<br>Op dezelfde manier zijn we een samenwerking aangegaan met <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Rebellen voor financiële en infrastructurele steun van de <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Klassiek ecosysteem.<br>Ten slotte is er misschien binnenkort een nieuwe ontdekkingsreiziger in de maak als de gemeenschap ervoor stemt!<br>Blijf op de hoogte voor nog meer!</p>
<h3 id="h3-V420Welke20voordelen20biedt20het20houden20van20NEBL20voor20houders96860"><a name="V4: Welke voordelen biedt het houden van NEBL voor houders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Welke voordelen biedt het houden van NEBL voor houders?</h3><p>Iedereen die NEBLs inneemt, heeft bestuursrechten en zorgt ook voor de beveiliging van het netwerk omdat we PoS zijn. Door te staken, kunt u stemmen over Neblio Improvement Proposals (NIP) met behulp van de NEBL-token. We hebben dit systeem een jaar geleden geïntroduceerd. U kunt elk gemeenschapsvoorstel indienen op onze GitHub (NeblioTeam), dat door de gemeenschap zal worden gestemd. Momenteel is er het nieuwe explorer-voorstel ter stemming.<br><img src="https://gimg2.gateimg.com/image/article/16741135584.png" alt=""><br>Voorstellen moeten minstens 20% stemdeelname behalen en minstens 50% “ja”-stemmen ontvangen om goedgekeurd te worden.</p>
<h3 id="h3-Q520Dus20hoe20kunnen20mensen20NEBL20inzetten20en20welke20prikkel20krijgen20ze20ervoor20terug199800"><a name="Q5: Dus hoe kunnen mensen NEBL inzetten en welke prikkel krijgen ze ervoor terug?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Dus hoe kunnen mensen NEBL inzetten en welke prikkel krijgen ze ervoor terug?</h3><p>U kunt $NEBL staken met behulp van een van onze wallets, zoals de Core Desktop wallet, met een rendement van 10% APY.<br>U <a href="/price/just-jst" rel="nofollow noopener noreferrer" target="_blank">ALLEEN</a> moet de Core Desktop wallet van Neblio downloaden van <a href="https://nebl.io/wallets/" rel="nofollow noopener noreferrer" target="_blank">https://nebl.io/wallets/</a> - het heeft een gebruiksvriendelijke interface.<br>Als u het voor de eerste keer downloadt, wacht dan tot het is gedownload en gesynchroniseerd.<br>Maak een Staker-adres aan in de Staking-portemonnee. Het is net als elk ander Neblio-adres, maar om koude-staking-delegaties te ontvangen. &gt; Ga naar het tabblad Koude Staking op de eigenaarsportemonnee, voeg het staker-adres toe, typ het bedrag van Nebl om te delegeren aan de staking-portemonnee en klik op maken.<br>Lees hier meer: <a href="https://medium.com/neblio-blog/announcing-neblio-cold-staking-c62649702ea3" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/neblio-blog/aankondiging-van-neblio-cold-staking-c62649702ea3</a></p>
<h3 id="h3-Q620Waar20kunnen20we20meer20leren20over20Neblio549824"><a name="Q6: Waar kunnen we meer leren over Neblio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Waar kunnen we meer leren over Neblio?</h3><p>De Neblio Universiteit, beschikbaar op onze website onder ‘Neblio U’, voorziet gebruikers van alles wat ze moeten weten over hoe ze moeten ontwikkelen op Neblio: <a href="https://nebl.io/neblio-university/" rel="nofollow noopener noreferrer" target="_blank">https://nebl.io/neblio-university/</a><br>We zijn toegewijd om het te verbeteren met een herontwerp van de gidsen als onderdeel van onze routekaart.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16741135035.png" alt=""><br>Op dezelfde manier raden we iedereen aan om op onze Medium te blijven letten, aangezien we daar ook updates en handleidingen plaatsen over onze nieuwste updates, bijv. hoe onze bruggen te gebruiken! <a href="https://medium.com/neblio-blog/" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/neblio-blog/</a></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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>