<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Nico Arq on Medium]]></title>
        <description><![CDATA[Stories by Nico Arq on Medium]]></description>
        <link>https://medium.com/@nijaar?source=rss-4d08fa1144a2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GxpesI2P743MatsBwSGopw.jpeg</url>
            <title>Stories by Nico Arq on Medium</title>
            <link>https://medium.com/@nijaar?source=rss-4d08fa1144a2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:02:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nijaar/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Understanding Local AI Engines: What Developers Building the Future Need to Know]]></title>
            <link>https://medium.com/@nijaar/understanding-local-ai-engines-what-developers-building-the-future-need-to-know-d4fe77cdf25b?source=rss-4d08fa1144a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4fe77cdf25b</guid>
            <category><![CDATA[local-ai-agent]]></category>
            <category><![CDATA[ai-agent-crypto]]></category>
            <category><![CDATA[local-ai-processing]]></category>
            <dc:creator><![CDATA[Nico Arq]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 03:54:20 GMT</pubDate>
            <atom:updated>2025-06-16T03:59:16.121Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding Local AI Agent Engines: What Developers Building the Future Need to Know</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*po6MX9Rp8SRoeU7E" /></figure><p>Building a truly local AI engine isn’t just about running models on your machine — it’s about creating an entire ecosystem that can handle complex workflows, multi-agent collaboration, and secure communication while keeping everything under your control. After spending countless hours building Shinkai, an open-source platform for local AI agents, I want to share the hard-earned lessons about what it really takes to build production-ready local AI infrastructure.</p><h3>Why This Matters Now</h3><p>The AI landscape is rapidly shifting toward local execution. While cloud-based AI services offer convenience, they come with significant drawbacks: data privacy concerns, network dependencies, usage costs, and vendor lock-in. Meanwhile, consumer hardware is becoming powerful enough to run sophisticated AI models locally. However, there’s a massive gap between “running a model” and “building a complete AI engine that can scale.”</p><p>This post explores the technical challenges we faced building Shinkai and why creating a local AI engine is far more complex than most developers realize. You’ll learn about the architectural decisions, security considerations, and engineering trade-offs that go into building a system that can compete with cloud-based alternatives while running entirely on local hardware.</p><h3>Fundamentals</h3><h3>Core Concept Definition</h3><p>A <strong>local AI engine</strong> is a complete software platform that orchestrates AI models, manages agent workflows, handles secure communication, and provides tooling infrastructure — all while running on local hardware without requiring external cloud services. Unlike simple model runners or inference servers, a local AI engine must solve the full stack of problems that make AI useful in production.</p><h3>Key Terminology</h3><ul><li><strong>AI Agent</strong>: An autonomous software entity that can reason, use tools, and collaborate with other agents</li><li><strong>Multi-Agent Collaboration</strong>: Multiple AI agents working together on complex tasks</li><li><strong>Local-First Architecture</strong>: Software designed to work primarily offline with optional cloud connectivity</li><li><strong>P2P Messaging</strong>: Direct communication between nodes without central servers</li><li><strong>Tool Execution</strong>: Running external code (Python, JavaScript, etc.) safely within the AI environment</li></ul><h3>Simple Example</h3><p>Consider a typical cloud AI workflow: You send a prompt to an API, it processes on remote servers, and returns a response. A local AI engine like Shinkai flips this entirely — the models run on your hardware, agents can spawn sub-agents, execute code locally, and communicate with other nodes directly through encrypted P2P channels.</p><h3>How It Works</h3><h3>Technical Mechanics</h3><p>Building Shinkai required solving five major architectural challenges:</p><h4>1. Cross-Platform Binary Management</h4><p>The first hurdle was ensuring our desktop app could run AI models without requiring users to install complex dependencies. Our solution bundles everything needed:</p><pre>&quot;externalBin&quot;: [<br>  &quot;external-binaries/shinkai-node/shinkai-node&quot;,<br>  &quot;external-binaries/shinkai-node/shinkai-tools-runner-resources/deno&quot;,<br>  &quot;external-binaries/shinkai-node/shinkai-tools-runner-resources/uv&quot;,<br>  &quot;external-binaries/ollama/ollama&quot;<br>]</pre><p>We automated the download and packaging of platform-specific binaries using a TypeScript script that handles Windows, macOS, and Linux variants. The complexity here isn’t just downloading files — it’s ensuring binary compatibility, handling different architectures, and managing the entire dependency tree.</p><h4>2. Secure Multi-Layer Message Encryption</h4><p>Local AI engines need bulletproof security since they handle sensitive data locally. We implemented a dual-layer encryption system using libsodium:</p><pre>pub fn encrypt_outer_layer(&amp;self, <br>    self_sk: &amp;EncryptionStaticKey,<br>    destination_pk: &amp;EncryptionPublicKey,<br>) -&gt; Result&lt;ShinkaiMessage, ShinkaiMessageError&gt;<br><br>pub fn encrypt_inner_layer(&amp;self,<br>    self_sk: &amp;EncryptionStaticKey, <br>    destination_pk: &amp;EncryptionPublicKey,<br>) -&gt; Result&lt;ShinkaiMessage, ShinkaiMessageError&gt;</pre><p>Each message gets signed, then optionally encrypted at the inner layer, then optionally encrypted again at the outer layer. This allows for complex routing scenarios where intermediate nodes can read routing metadata without accessing the actual content. The challenge is managing the signing/encryption order correctly — get it wrong and messages become unreadable.</p><h4>3. P2P Networking with LibP2P</h4><p>Building reliable peer-to-peer communication required implementing a complete networking stack on top of LibP2P:</p><pre>pub struct LibP2PProxy {<br>    pub clients: LibP2PClients,<br>    pub pk_to_clients: LibP2PPKtoIdentity, <br>    pub registry: ShinkaiRegistry,<br>    pub node_name: ShinkaiName,<br>    pub identity_secret_key: SigningKey,<br>}</pre><p>Our P2P layer handles peer discovery, NAT traversal, relay protocols, and maintains compatibility with traditional TCP networking as a fallback. Every connection must be authenticated against an on-chain registry to prevent unauthorized access.</p><h4>4. Local Tool Execution</h4><p>One of Shinkai’s most powerful features is running arbitrary Python and Deno code locally within AI agent workflows. This required building a complete sandboxing system:</p><pre>let tool = PythonRunner::new(<br>    CodeFiles { files: code_files.clone(), entrypoint: &quot;index.py&quot;.to_string() },<br>    config_json,<br>    Some(PythonRunnerOptions {<br>        uv_binary_path: PathBuf::from(<br>            env::var(&quot;SHINKAI_TOOLS_RUNNER_UV_BINARY_PATH&quot;)<br>                .unwrap_or_else(|_| &quot;./shinkai-tools-runner-resources/uv&quot;.to_string()),<br>        ),<br>        shinkai_node_location: ShinkaiNodeLocation { <br>            protocol: &quot;http&quot;.into(), <br>            host: api_ip, <br>            port: api_port <br>        },<br>    }),<br>);</pre><p>The system manages virtual environments, dependency isolation, secure file mounting, and result collection — all while ensuring the host system remains secure.</p><h3>Architecture Flow Diagram</h3><pre>┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐<br>│   Desktop App   │    │   Shinkai Node   │    │   Ollama + LLMs │<br>│   (Tauri/React) │◄──►│   (Rust Core)    │◄──►│   (Embedded)    │<br>└─────────────────┘    └──────────────────┘    └─────────────────┘<br>         │                        │                        │<br>         │                        ▼                        │<br>         │              ┌──────────────────┐               │<br>         │              │   Tool Runners   │               │<br>         │              │ (Python + Deno)  │               │<br>         │              └──────────────────┘               │<br>         │                        │                        │<br>         ▼                        ▼                        ▼<br>┌─────────────────────────────────────────────────────────────┐<br>│                    P2P Network Layer                        │<br>│              (LibP2P + Encrypted Messaging)                 │<br>└─────────────────────────────────────────────────────────────┘</pre><h3>Practical Applications</h3><h3>Use Cases</h3><p><strong>Enterprise AI Workflows</strong>: Companies can run sophisticated AI agents that process sensitive data entirely on-premises, eliminating data privacy concerns while maintaining full control over their AI infrastructure.</p><p><strong>Developer Tools</strong>: Software teams can create AI agents that understand their codebase, run tests, generate documentation, and collaborate on complex tasks without sending proprietary code to external services.</p><p><strong>Research Environments</strong>: Academics can build multi-agent simulations and experiments that run locally, ensuring reproducibility and eliminating cloud costs for long-running research projects.</p><p><strong>Financial Trading Agents</strong>: Build market-making AI agents that execute trades, monitor portfolios, and respond to market conditions in real-time. Since Shinkai is crypto-native with built-in wallet support, private keys never leave your local machine — eliminating the risk of exchange hacks or third-party custody. Your trading algorithms and strategies remain completely private while agents can interact with DeFi protocols and centralized exchanges securely.</p><h3>Implementation Examples</h3><p>Here’s how we handle the complexity of loading and managing local AI models — what looks like simple embedding model loading is actually a sophisticated orchestration of multiple systems:</p><pre>pub fn get_model_data(llm_models_path: &amp;Path) -&gt; &amp;&#39;static [u8] {<br>    static FULL_MODEL_DATA: OnceLock&lt;Vec&lt;u8&gt;&gt; = OnceLock::new();<br>    <br>    FULL_MODEL_DATA.get_or_init(|| {<br>        let model_path = llm_models_path.join(&quot;snowflake-arctic-embed-xs-f16.GGUF&quot;);<br>        <br>        let mut file = match File::open(&amp;model_path) {<br>            Ok(file) =&gt; file,<br>            Err(err) =&gt; {<br>                eprintln!(&quot;Failed to open embedding model file at {:?}: {}&quot;, model_path, err);<br>                return Vec::new();<br>            }<br>        };<br>        <br>        let mut buffer = Vec::new();<br>        if let Err(err) = file.read_to_end(&amp;mut buffer) {<br>            eprintln!(&quot;Failed to read embedding model file: {}&quot;, err);<br>            return Vec::new();<br>        }<br>        <br>        buffer<br>    }).as_slice()<br>}</pre><p>But this is just the beginning. When the ShinkaiNodeManager starts, it orchestrates a complex bootstrap sequence — launching Ollama, checking existing models, and conditionally creating new ones:</p><pre>pub async fn spawn(&amp;mut self) -&gt; Result&lt;(), String&gt; {<br>    self.emit_event(ShinkaiNodeManagerEvent::StartingOllama);<br>    match self.ollama_process.spawn(None).await { ... }<br>    let ollama_api = OllamaApiClient::new(ollama_api_url);<br>    let installed_models = match ollama_api.tags().await {<br>        Ok(response) =&gt; response.models.iter().map(|m| m.model.clone()).collect(),<br>        Err(e) =&gt; {<br>            log::warn(&quot;ollama api tags request failed, fallback assuming no local models&quot;);<br>            vec![]<br>        }<br>    };<br>    let default_embedding_model = self.shinkai_node_process<br>        .get_options().default_embedding_model.unwrap();<br>    <br>    if !installed_models.contains(&amp;default_embedding_model.to_string()) {<br>        // Use the embedded GGUF model<br>        let gguf_data = embedding_model::get_model_data(&amp;self.llm_models_path);<br>        <br>        match ollama_api.create_model_from_gguf(&amp;default_embedding_model, gguf_data).await {<br>            Ok(_) =&gt; { <br>                self.emit_event(ShinkaiNodeManagerEvent::CreatingModelDone {<br>                    model: default_embedding_model.to_string(),<br>                });<br>            }<br>            Err(e) =&gt; {<br>                error!(&quot;failed to create model from gguf: {}&quot;, e);<br>                self.kill().await;<br>                return Err(e.to_string());<br>            }<br>        }<br>    }<br>}</pre><p>The create_model_from_gguf method demonstrates the intricate validation and upload process required for local model management:</p><pre>pub async fn create_model_from_gguf(&amp;self, model_name: &amp;str, gguf_data: &amp;[u8]) -&gt; Result&lt;(), String&gt; {<br>    // Validate GGUF magic number<br>    if gguf_data.len() &lt; 4 || &amp;gguf_data[0..4] != b&quot;GGUF&quot; {<br>        return Err(&quot;Invalid GGUF file format&quot;.to_string());<br>    }<br><br>    // Upload GGUF data as a blob to Ollama<br>    let digest = self.upload_blob(gguf_data).await?;<br>    <br>    // Verify the blob was uploaded correctly<br>    let check_url = format!(&quot;{}/api/blobs/{}&quot;, self.base_url, digest);<br>    let head_response = client.head(&amp;check_url).send().await?;<br>    if !head_response.status().is_success() {<br>        return Err(&quot;Failed to verify uploaded blob&quot;.to_string());<br>    }<br>    // Create the model using the uploaded blob<br>    let mut files = HashMap::new();<br>    files.insert(&quot;arctic.gguf&quot;.to_string(), digest);<br>    let create_request = OllamaApiCreateRequest { <br>        model: model_name.to_string(), <br>        files <br>    };<br>    let response = client.post(&amp;url).json(&amp;create_request).send().await?;<br>    // ... handle response and potential errors<br>}</pre><p>This seemingly simple model loading actually coordinates: static memory management with OnceLock for thread-safe singleton access, graceful error handling across file I/O and network operations, GGUF format validation to ensure model integrity, async blob upload with verification, integration with Ollama&#39;s API for model creation, and event emission for UI state updates. The complexity comes from ensuring this works reliably across different operating systems, handling partial failures gracefully, and maintaining consistency between the embedded model files and the running Ollama instance.</p><h3>Best Practices</h3><p><strong>Start with a Monorepo</strong>: We use Nx to manage our complex codebase across multiple languages and platforms. This enables shared tooling, consistent builds, and coordinated releases.</p><p><strong>Embrace Async Everywhere</strong>: Local AI engines involve heavy I/O, network operations, and long-running computations. Design your architecture around async/await patterns from day one.</p><p><strong>Bundle Dependencies Aggressively</strong>: Don’t rely on users having the right Python version, Node.js runtime, or system libraries. Bundle everything you need and manage the complexity internally.</p><p><strong>Design for Offline-First</strong>: Network connectivity is unreliable. Your AI engine should work perfectly in airplane mode and gracefully enhance capabilities when connectivity is available.</p><h3>Advanced Considerations</h3><h3>Edge Cases</h3><p><strong>Multi-Platform Binary Compatibility</strong>: ARM vs x86, different libc versions, Windows permission models, macOS notarization requirements. Each platform has unique challenges that multiply across the dependency stack.</p><p><strong>Memory Management with Large Models</strong>: Loading multiple 7–30B+ parameter models requires careful memory planning. You need strategies for model swapping, quantization, and graceful degradation when resources are limited.</p><p><strong>Concurrent Tool Execution</strong>: When multiple agents run Python/Deno tools simultaneously, you need sophisticated resource isolation to prevent interference and ensure security.</p><h3>Performance Implications</h3><p>The performance profile of a local AI engine is fundamentally different from cloud services:</p><pre>pub struct JobQueueManager&lt;T: Debug&gt; {<br>    queues: Arc&lt;Mutex&lt;HashMap&lt;String, MutexQueue&lt;T&gt;&gt;&gt;&gt;,<br>    subscribers: Arc&lt;Mutex&lt;HashMap&lt;String, Vec&lt;Subscriber&lt;T&gt;&gt;&gt;&gt;&gt;,<br>    all_subscribers: Arc&lt;Mutex&lt;Vec&lt;Subscriber&lt;T&gt;&gt;&gt;&gt;,<br>    db: Weak&lt;SqliteManager&gt;,<br>    prefix: Option&lt;String&gt;,<br>}</pre><p>Our job queue manager persists state to SQLite while maintaining in-memory performance. The challenge is balancing durability, performance, and memory usage as the system scales from single-user to multi-agent scenarios.</p><p><strong>CPU vs GPU Utilization</strong>: Local hardware is limited. You need intelligent scheduling to balance LLM inference, tool execution, and system operations across available cores and accelerators.</p><p><strong>Storage I/O Patterns</strong>: Unlike cloud services with fast networking, local systems are bottlenecked by storage I/O. Vector databases, model weights, and conversation history create complex I/O patterns that need optimization.</p><h3>Security Considerations</h3><p>Local AI engines face unique security challenges:</p><p><strong>Code Execution Sandboxing</strong>: When agents run arbitrary Python/Deno code, you need robust sandboxing that prevents system compromise while allowing legitimate file system access.</p><p><strong>Key Management</strong>: Local systems can’t rely on cloud HSMs. We implemented a complete cryptographic system using libsodium with careful key derivation and storage.</p><p><strong>P2P Authentication</strong>: In distributed scenarios, every peer connection must be authenticated. Our solution ties into an on-chain registry to ensure only authorized nodes can communicate.</p><h3>Conclusion</h3><h3>Key Takeaways</h3><p>Building a local AI engine that can interact with external AI agents is significantly more complex than most developers anticipate. It requires expertise across:</p><ul><li><strong>Systems Programming</strong>: Managing binaries, processes, and resources across platforms</li><li><strong>Cryptography</strong>: Implementing secure communication without cloud security services</li><li><strong>Distributed Systems</strong>: P2P networking, consensus, and fault tolerance</li><li><strong>AI/ML Infrastructure</strong>: Model management, inference optimization, and resource scheduling</li><li><strong>Developer Experience</strong>: Making complex systems simple for end users</li></ul><p>The technical debt accumulates quickly because you’re building infrastructure that cloud providers usually handle. However, the benefits — data privacy, cost control, and true ownership of your AI stack — make it worthwhile for many use cases.</p><h3>Further Reading</h3><ul><li><a href="http://github.com/dcSpark/shinkai-local-ai-agents">Shinkai GitHub Repository</a> — Explore the complete codebase</li><li><a href="https://tauri.app/">Tauri Documentation</a> — For cross-platform desktop app development</li><li><a href="https://docs.libp2p.io/">LibP2P Specifications</a> — Understanding P2P networking protocols</li><li><a href="https://ollama.ai/docs">Ollama Documentation</a> — Local LLM execution and management</li></ul><h3>Implementation Challenge</h3><p>Ready to dive deeper? Try building a minimal local AI agent that can:</p><ol><li>Load a small language model (like Qwen or DeepSeek)</li><li>Execute Python / Typescript code securely in a sandbox</li><li>Persist conversation history to local storage</li><li>Communicate with another instance over P2P</li></ol><p>Start simple, but prepare for the complexity to grow exponentially as you add real-world features. The Shinkai codebase provides a working example of how to solve these challenges at scale.</p><p>Building local AI infrastructure is hard, but it’s also the future. The companies and developers who master these challenges today will have significant advantages as the industry shifts toward local-first AI systems.</p><p>And if you want to give it a try to Shinkai, you can get it on <a href="https://shinkai.com/">https://shinkai.com</a> for Windows, Mac and Linux.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4fe77cdf25b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fracada: A protocol for fractionalizing NFTs]]></title>
            <link>https://medium.com/dcspark/fracada-a-protocol-for-fractionalizing-nfts-14b9017b3d91?source=rss-4d08fa1144a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/14b9017b3d91</guid>
            <category><![CDATA[cardano]]></category>
            <category><![CDATA[eutxo]]></category>
            <category><![CDATA[plutus]]></category>
            <dc:creator><![CDATA[Nico Arq]]></dc:creator>
            <pubDate>Tue, 28 Sep 2021 19:40:57 GMT</pubDate>
            <atom:updated>2021-09-28T19:40:57.000Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Non fungible tokens (NFTs) have found a very popular application as on-chain representation of different assets, particularly artwork.</p><p>A natural step is fractioning the NFT: what if you have a NFT you want to share with your friends, or if you buy an NFT together, how do you indicate shared ownership?</p><p>Here we present a protocol where you can fraction your NFT and get back a limited amount of of tokens representing fractions of that NFT (and they can be traced back to it).</p><h3>Design</h3><p>The contract will either receive the NFT to lock and a number in the redeemer indicating how many fractions (tokens) of the NFT to mint or receive all the fraction tokens and pay back the NFT while burning the tokens.</p><h3>Fractionating the NFT</h3><p>Fractioning is done in two steps:</p><ol><li>Lock the NFT in the contract.</li><li>Mint the tokens and pay to the public key that locked the NFT in the previous step.</li></ol><h3>Locking the NFT</h3><p>This step locks the NFT in the contract with the datum containing the nft asset class and the owner, we set the amount of fractions to 0 (no fractions yet)</p><h4>Off-chain</h4><p>We build the datum and lock it in the script:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*1585S6t6yIkaLtvGOVl-wA.png" /></figure><h3>Minting the tokens</h3><p>To mint and pay the fraction tokens, we use the minting policy and the fraction validator together:</p><p>The minting policy will allow minting if the token is paid from the validator to the validator again and the specified amount of tokens are actually minted.</p><p>The validator will check that the fraction count in the datum changes from 0 to the actual number, the owner is preserved in the datum, and the correct number of tokens are minted.</p><h4>Off-chain</h4><p>The offchain code will look for the UTxO containing the NFT, update the total fraction in the datum (thus spending and paying the NFT back to the validator) and use the minting script to mint the fraction tokens:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*i7PFrTnu8Y2wTUF2Zc1KMw.png" /></figure><h4>On-chain validator</h4><p>The minting spending path in the validator will check that the NFT has’t been fractioned yet (the fraction counter in the input datum is 0), that the new count matches the requested amount of tokens, that the requested amount is minted and the owner is preserved in the datum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*8bZEYpYXUWLonQJYz1ehBA.png" /></figure><h4>Minting script</h4><p>The minting script should check the requested amount of tokens is minted and the NFT is spent and locked from the fractionNFT validator</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*gDnrQBcnxeXNNb1ve7uBdA.png" /></figure><h3>Returning the NFT</h3><p>To return the NFT:</p><p><em>User:</em> has to provide all the minted tokens.</p><p><em>Off-chain</em>: the contract has to burn the tokens and pay the NFT</p><p><em>On-chain validator</em>: verify the NFT is paid to the user and the correct tokens are burned.</p><p><em>Minting script</em>: Burn the requested amount of tokens</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*M5MA3O-zfnt3dOSblBbG5A.png" /></figure><h4>Off-chain</h4><p>To get the NFT back, the signer has to collect all the fraction tokens and burn them while spending the NFT from the contract.</p><p>When returning the NFT, we look for the NFT in the UTxOs locked by the contract, extract the datum to find the tokens to burn, and pay back the NFT to the signer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*mRbdBg992AroblXsXDxT2g.png" /></figure><h4>On-chain validator</h4><p>The validator will only release the NFT to the signer if the fraction tokens are burned.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*jd5faF_s_Rle2l2LvTiDGw.png" /></figure><h4>Minting script</h4><p>The minting script should check only the requested amount of tokens are burned and the NFT is paid back to the signer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*IcTMHs3U2txRdsZZl1G2fQ.png" /></figure><h3>Conclusion</h3><p>This is a simple contract that showcases a few useful techniques for developing smart contracts in Plutus: minting &amp; burning, using the datum to keep protocol state, interrelate minting and validator scripts, utxo filtering and selection, multiple spending path validators, and more.</p><p>Although the initial application of fractionating an NFT to share with friends is almost a novelty, the core protocol of locking a token and issue a number of special tokens, returning the initial token after the special tokens are burned can be integral part of other protocols like governance (where you lock your governance tokens in exchange of voting tokens), access control/initialization of processes (locking a control token will give you back tokens/NFTs to start dApp state machines), etc. After all, <a href="https://medium.com/dcspark/every-eutxo-dapp-will-use-nfts-and-heres-why-fd87e6a8c9a6">Every eUTxO dApp will use NFTs</a>.</p><p>The full project can be found at <a href="https://github.com/dcSpark/fracada">https://github.com/dcSpark/fracada</a></p><p>As a reminder, the code of this project is not audited, but we present it with the goal of sharing smart contract knowledge and collaborating with the community.</p><p><strong>Thanks</strong> to our lead Plutus developer for writing the blogpost and coding the project!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=14b9017b3d91" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dcspark/fracada-a-protocol-for-fractionalizing-nfts-14b9017b3d91">Fracada: A protocol for fractionalizing NFTs</a> was originally published in <a href="https://medium.com/dcspark">dcSpark</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing dcSpark]]></title>
            <link>https://medium.com/dcspark/introducing-dcspark-bddd8d82269a?source=rss-4d08fa1144a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/bddd8d82269a</guid>
            <category><![CDATA[smart-contracts]]></category>
            <category><![CDATA[urbit]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[cardano]]></category>
            <dc:creator><![CDATA[Nico Arq]]></dc:creator>
            <pubDate>Fri, 09 Jul 2021 15:14:34 GMT</pubDate>
            <atom:updated>2021-09-24T14:39:36.977Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9_nhE0WHK3jkcGi2XLxqQQ.jpeg" /></figure><p><strong>dcSpark</strong> is a new startup which came to be just three months ago (April 2021) and is founded by Nicolas Arqueros, Sebastien Guillemot and Robert Kornacki. The idea to start a new company came out of realizing that it was the only way for the founders to fully focus on their passion of creating B2C products that could boost the adoption of crypto based solutions.</p><p><strong>dcSpark </strong>is a product based Blockchain company focused on building critical products and solutions on top of the most promising crypto projects in the space; currently focused on Solana, Urbit and Cardano.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*teIiSdeNSF48FHjMTZQeMA.png" /><figcaption>Blockchain Layers</figcaption></figure><p>Unlike most of the other companies that develop products, we are able to move between the top two layers (Application Layer and Development &amp; Libraries Layer) while also having a deep understanding of the bottom layer (Protocol Layer). This gives us a unique competitive edge when creating products as we don’t require waiting for others to develop libraries or other components we need. Instead we develop them ourselves and help improve the community and ecosystem at large by open sourcing and making them available for all.</p><p>The next obvious question that you may find yourself asking: What products is dcSpark working on? As a teaser we will give you one hint per product so that you can get a taste of what will be coming in the near future:</p><p>— — — —</p><p><strong>Product 1: Flint (Multichain)</strong> Plutus is around the corner and users will need software to interact with all of the smart contracts available straight from the web browser.</p><p><strong>Product 2: Milkomeda (Multichain) </strong>We have invented a brand new concept called <strong><em>wrapped smart contracts</em></strong> which will add jet fuel to multichain adoption. Can you guess what Milkomeda is?</p><p><strong>Product 3 (Urbit) </strong>We received a grant from the Urbit Foundation to build an exciting project that will streamline the process of creating off-chain p2p web apps. Take a look around and try to find the grant proposal for a deep dive on how this will change the game for off-chain decentralization.</p><p>— — — —</p><p>As you can see, we are quite the ambitious team!</p><p>To make everything in our plans a reality we have secured a seed round of ~1.4M USD. We would like to thank all of our investors for joining in what is going to be a crazy (and hopefully fun) ride as we enter into our first major growth period as a company.</p><p>Our investors include:</p><ul><li>WaveGP (IOHK)</li><li>Graph Ventures</li><li>SOSV</li><li>p23</li><li>Antarticx</li><li>And seven angel investors</li></ul><p>For those who don’t know much about us (the founders of dcSpark), we originally met and got to know each other while working at Emurgo. Some further information about each of us:</p><ul><li><strong>Nicolas Arqueros</strong> CEO @ dcSpark (<a href="https://www.linkedin.com/in/nicoarqueros/">https://www.linkedin.com/in/nicoarqueros/</a>) was CTO at Emurgo.</li><li><strong>Sebastien Guillemot</strong> CTO @ dcSpark (<a href="https://www.linkedin.com/in/sebastien-guillemot-45786782/">https://www.linkedin.com/in/sebastien-guillemot-45786782/</a>) was the VP of Engineering at Emurgo and currently co-leads the CIP process in Cardano.</li><li><strong>Robert Kornacki</strong> CSO @ dcSpark (<a href="https://www.linkedin.com/in/robert-kornacki-5036b8176/">https://www.linkedin.com/in/robert-kornacki-5036b8176/</a>) was the Head of Research at Emurgo and currently is a board member of the Ergo Foundation.</li></ul><p>During our time at Emurgo our team had successfully lead several projects which have been pivotal for both developers and end users. Some of these include:</p><ol><li>Nico and Seba lead Yoroi, which is one of the most well known projects in Cardano as the original Cardano light wallet. It has more than 500,000 users and has helped secure over 20% of the network’s assets (10 billion dollars at today’s valuation).</li><li>Seba led development of cardano-serialization-library, which is the go to library for generating Cardano transactions which is currently used by Coinbase and several wallets in the ecosystem.</li><li>Rob and Nico lead efforts in multiple projects in the Ergo ecosystem as a part of the Emurgo &lt;&gt; Ergo partnership. This included the development of a stablecoin project (AgeUSD) which held $10 million in assets at its peak, the first Ergo Summit, oracle pools, and adding support for Ergo dApps in Yoroi.</li></ol><p>With all of the above experience under our belts, we know that even though we have ambitious plans ahead of us, we can do the hard work to make them a reality. Our goal as a company is to play a critical role in the adoption of crypto projects that we believe have the most growth potential (under-valued) in the space.</p><p>In the coming weeks we will begin to unveil the projects we have hinted at, and thus are looking forward to seeing the community’s response as we start showing off all of the exciting research, software, and products that we have been working on in quiet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X472uTS3jk8RY10RK4K4uQ.jpeg" /><figcaption>Devs Wanted for hazardous journey</figcaption></figure><p>And last but not least, If you like to work on hard problems, learn in a fast-paced environment, and you have a unique sense of humor like ours, we are <a href="https://www.getonbrd.com/companies/dcspark">hiring for multiple positions</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bddd8d82269a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dcspark/introducing-dcspark-bddd8d82269a">Introducing dcSpark</a> was originally published in <a href="https://medium.com/dcspark">dcSpark</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>