Conclusive Engineering KSTR-SAMA5D27  is an ultra-compact (70x50mm) single board computer (SBC) powered by a Microchip SAMA5D27 Arm Cortex-A5 processor microprocessor clocked at 500 MHz paired with 256MB LPDDR2 (system-in-package). The board also features a microSD card slot and EEPROM for storage/configuration, Fast Ethernet, WiFi 4, and Bluetooth 4.1 connectivity, a USB-C port, two GPIO headers, and supports USB and battery power. It’s designed for IoT devices, smart systems, and edge computing applications. Conclusive Engineering KSTR-SAMA5D7 specifications: SiP –  Microchip SAMA5D27 CPU – Arm Cortex-A5 microprocessor @ 500 MHz System Memory – 256 MB LPDDR2 Storage MicroSD card slot 4KB EEPROM Networking 10/100Mbps Ethernet RJ45 jack 2.4 GHz WLAN IEEE 802.11 b/g/n and Bluetooth 4.1 USB 1x USB 2.0 OTG Type-C connector 1x USB 2.0 Host on expansion header Expansion 34-pin and 30-pin connectors 2x Flexcom (configurable: I2C, SPI, UART) I2C 6-channel ADC with Vref 10-bit ISC (Image Sensor Controller), 10-bit […]

The post Conclusive Engineering KSTR-SAMA5D27 is an ultra-compact, low-power SBC based on Microchip SAMA5D57 SiP appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/04/16/conclusive-engineering-kstr-sama5d27-ultra-compact-sbc-microchip-sama5d57-sip/

The post Conclusive Engineering KSTR-SAMA5D27 is an ultra-compact, low-power SBC based on Microchip SAMA5D57 SiP appeared first on IPv6.net.

Scale Computing kondigt het Velocity Partnerprogramma aan, een vervanging voor volumegerichte partnermodellen. Het programma richt zich op snellere dealuitvoering, competentiegebaseerde beloningen en minder afhankelijkheid van leveranciersmiddelen. Daarmee wil het bedrijf partners beter positioneren in de groeiende markt voor edge computing en gedistribueerde IT.

Scale Computing presenteert het Velocity Partnerprogramma, dat traditionele volumemodellen vervangt en is ontworpen om partners zelfstandiger te laten opereren. Volgens het bedrijf helpt het programma partners bij het begeleiden van klanten tijdens overstappen naar private cloud — van architectuurontwerp tot implementatie en doorlopend beheer.

Het bedrijf stelt dat het nieuwe programma operationele frictie vermindert en de doorlooptijd van offerte tot deal verkort. Daarnaast geeft Scale Computing aan dat partners een groter deel van de totale projectwaarde kunnen benutten, met name op het gebied van professionele diensten.

Competentie als basis voor doorgroei

Het Velocity Partnerprogramma kent een gelaagde opbouw waarbij doorgroei is gekoppeld aan aantoonbare expertise. Scale Computing meldt dat het programma zowel een laagdrempelige instap biedt voor nieuwe partners als erkenning geeft aan partners met een hoge betrokkenheid en bewezen capaciteiten.

Kyle Fenske, Global Channel Chief bij Scale Computing, geeft aan dat het programma tot stand is gekomen op basis van directe feedback van partners die vroegen om meer differentiatie in lijn met hun investeringen. Fenske stelt dat het programma partnergedreven groei op schaal ondersteunt en partners in staat stelt zelfstandiger deals te sluiten.

Volgens Fenske biedt het programma een alternatief voor zogenoemde rip-and-replace-transities, wat de frictie voor partners bij klantoverstappen verkleint.

Vier pijlers

Scale Computing omschrijft het Velocity Partnerprogramma aan de hand van vier onderdelen. Ten eerste een snellere weg naar omzet, door minder operationele drempel en een helder pad naar de eerste deal. Ten tweede competentiegebaseerde beloningen, waarbij expertise de economische waarde bepaalt. Ten derde voorspelbare marges en beschermde deals via incentives en beschermingsmechanismen die kanaalconflicten moeten beperken. Ten vierde een partner-first ervaring met duidelijkere verwachtingen en ondersteuning bij het opbouwen van een duurzame praktijk.

Breed productportfolio als fundament

Het programma bouwt voort op het productportfolio van Scale Computing. Daartoe behoren onder meer SC//HyperCore, een virtualisatiesuite die software, servers en storage integreert in één oplossing, en SC//Fleet Manager, waarmee edge-infrastructuur centraal te beheren valt via Zero-Touch Provisioning. Verder kondigt het bedrijf SC//Reliant aan als hardware- en cloudagnostisch edgeplatform voor organisaties met meerdere locaties, en SC//Connect als cloud-native SD-WAN- en SASE-oplossing.

Fenske verwacht dat de groei van edge computing en gedistribueerde IT leidt tot meer locaties en meer complexiteit, en dat partners daardoor behoefte hebben aan programma’s die marges beschermen en expertise belonen.

Het bericht Scale Computing introduceert nieuw partnerprogramma gericht op autonomie verscheen eerst op ChannelConnect.

Read more here: https://www.channelconnect.nl/partnerkansen/scale-computing-introduceert-nieuw-partnerprogramma-gericht-op-autonomie/

The post Scale Computing introduceert nieuw partnerprogramma gericht op autonomie appeared first on IPv6.net.

Read more here: https://blog.apnic.net/2026/04/16/podcast-ip-networking-in-deep-space/

The post [Podcast] IP networking in deep space appeared first on IPv6.net.

In the automotive industry, “drive-by-wire” means that a traditionally mechanical linkage, like a throttle cable, has been replaced by an electronic actuator. That can eliminate design constraints and even save money. SciFientist was able to apply those same drive-by-wire principles to this 3D-printed micro milling machine.

Machine tools, including vertical mills, are usually either CNC, manual, or power-assisted. In that last scenario, there is usually a simple motor that rotates a lead screw, so the user doesn’t have to crank the handle a bunch of times to traverse long distances. The motor can feed more consistently than a person can as well.

But this 3D-printed micro mill is different, because it entirely replaces the traditional manual cranks with motors and can only be controlled electronically — just like a drive-by-wire car.

Each axis has a lead screw turned by a stepper motor, controlled by an Arduino UNO Rev3 with a CNC Shield. The Arduino moves the motors in response to user input through a joystick and buttons. But in this incarnation, there isn’t any provision for true CNC operation — though SciFientist has plans for a second version with that capability.

What also stands out about this micro mill is its 3D-printed frame. That isn’t rigid at all by machine tool standards, but it should be good enough for the PCB milling that SciFientist plans to tackle with the machine.

While this is just the first step on the way to more conventional CNC milling, the drive-by-wire control is interesting. With linear position feedback on each axis — essentially a DRO— and fine motor movement, it would allow for many of the benefits of manual milling, but in a compact and affordable package that ignores the design constraints of manual mills.

The post A 3D-printed “drive-by-wire” micro mill for your desktop appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/04/15/a-3d-printed-drive-by-wire-micro-mill-for-your-desktop/

The post A 3D-printed “drive-by-wire” micro mill for your desktop appeared first on IPv6.net.

Managing IoT devices at scale is hard, but we believe finding the right resources at the right time shouldn’t feel like searching through a haystack! That’s why we built Smart Folders in Arduino Cloud – saved searches that stay alive and update automatically in real-time. This builds on recent improvements announced in Arduino Cloud, including a dark theme and a new Thing page.

What are Smart Folders?

Smart Folders bring dynamic, rule-based organization to Arduino Cloud, an all-in-one platform to bring your IoT projects to life quickly. If you’ve used Smart Folders in macOS or Google Drive, the concept will feel familiar – but we’ve tailored it specifically for IoT fleet management.

Instead of manually organizing resources into static folders that get outdated immediately, you create folders based on criteria that matter to your workflow: device status, location, connection type, or custom keywords. Arduino Cloud automatically populates these folders and keeps them updated as your fleet evolves.

Where you can create Smart Folders

Smart Folders are available across all major IoT listing pages:

• Things
• Devices
• Dashboards
• Triggers

This universal availability means consistent organization across your entire Arduino Cloud workspace.

How to create a Smart Folder

Creating a Smart Folder is straightforward: here’s a quick step-by-step guide.

1. Define your criteria

Use search and filter controls to narrow down your resources. You can combine multiple filter types:

• Keywords: Multiple search strings as individual criteria (press Enter after each)
• Status filters: Device status
• Technical filters: Device type, connection type, timezone
• Metadata filters: Creation date, tags, and attributes

^{Select multiple active filters such as keywords, status, device or connection type}

2. Save as a Smart Folder

Save your filters with a descriptive name. Arduino Cloud immediately creates a folder that automatically includes all matching resources.

^{Arduino Cloud instantly generates a folder containing all matching resources}

3. Manage and refine

Here are the key actions you can take to keep your Smart Folders always functional.

• Duplicate: Create variations quickly
• Edit filters: Adjust criteria when requirements change
• Delete: Remove unused folders

^{The Smart Folder management options menu}

Why Smart Folders matter in Arduino Cloud

^{Your Smart Folders appear at the top}

Traditional folders become stale immediately and require constant manual maintenance. Smart Folders stay current automatically. Add a new device matching existing criteria? It appears in the right folders instantly. Change a device’s status? It moves between folders automatically. Update tags? Your organization adapts in real time.

Watch Marta Barbero, our Lead Product Manager, explain what you can do with Smart Folders in Arduino Cloud.

Getting started 

Smart Folders are available now. Here’s how to start:

1. Log in to Arduino Cloud.
2. Navigate into your IoT builder side bar: Things, Devices, Dashboards, or Triggers.
3. Select the Smart Folder folder icon.

4. Apply filters using search and filter controls.
5. Save as Smart Folder with a descriptive name.
6. Pin important folders to your sidebar for quick access.

Start simple with one or two folders for your most common searches, such as “My Active Projects” or “Offline Devices,” and see how instant filtered views change your workflow!

Try Smart Folders today in Arduino Cloud, as well as our AI Assistant. Share your feedback in the Arduino community forums or reach out to our support team.

Arduino is a trademark or registered trademark of Arduino S.r.l.

The post Organize your IoT fleet in Arduino® Cloud with Smart Folders appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/04/15/organize-your-iot-fleet-in-arduino-cloud-with-smart-folders/

The post Organize your IoT fleet in Arduino® Cloud with Smart Folders appeared first on IPv6.net.

Read more here: https://labs.ripe.net/author/ejaw/noisy-routers-investigating-the-make-up-of-route-collector-data/

The post Noisy Routers: Investigating the Make-Up of Route Collector Data appeared first on IPv6.net.

The LimeSDR Micro M.2 2280 software-defined radio (SDR) card combines an NXP LA9310 baseband processor and a Lime Microsystems LMS7002M transceiver, and targets integration into portable or embedded solutions with a spare M.2 PCIe Gen3 x1 socket. The module is offered in a 1T2R configuration by default, but can be expanded to 1T4R via an FPC connector, supports a 30 MHz to 3.8 GHz frequency range, and up to 100 MHz bandwidth. Target applications include 4G LTE/5G, future RAN research, custom user equipment/modems, drone communications, IoT, satellite communications, and custom waveform generation. LimeSDR Micro M.2 SDR card specifications: SoC – NXP LA9310 programmable baseband processor Vector Signal Processing Accelerator (VSPA) Gen 2 up to 80 GFLOPs Control Processor – Arm Cortex-M4 at up to 307 MHz Storage – 512 Kbit EEPROM memory for NXP LA9310 initial configuration RF Lime Microsystems LMS7002M RF transceiver Channels – 1T2R expandable to 1T4R via […]

The post LimeSDR Micro M.2 2280 SDR card pairs NXP LA9310 baseband processor with LMS7002M RF transceiver (Crowdfunding) appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/04/15/limesdr-micro-m-2-2280-sdr-card-pairs-nxp-la9310-baseband-processor-with-lms7002m-rf-transceiver/

The post LimeSDR Micro M.2 2280 SDR card pairs NXP LA9310 baseband processor with LMS7002M RF transceiver (Crowdfunding) appeared first on IPv6.net.

As AI Large Language Models and harnesses like OpenCode and Claude Code become increasingly capable, we see more users kicking off sandboxed agents in response to chat messages, Kanban updates, vibe coding UIs, terminal sessions, GitHub comments, and more.

The sandbox is an important step beyond simple containers, because it gives you a few things:

• Security: Any untrusted end user (or a rogue LLM) can run in the sandbox and not compromise the host machine or other sandboxes running alongside it. This is traditionally (but not always) accomplished with a microVM.

• Speed: An end user should be able to pick up a new sandbox quickly and restore the state from a previously used one quickly.

• Control: The trusted platform needs to be able to take actions within the untrusted domain of the sandbox. This might mean mounting files in the sandbox, or controlling which requests access it, or executing specific commands.

Today, we’re excited to add another key component of control to our Sandboxes and all Containers: outbound Workers. These are programmatic egress proxies that allow users running sandboxes to easily connect to different services, add observability, and, importantly for agents, add flexible and safe authentication.

Here’s a quick look at adding a secret key to a header using an outbound Worker:

class OpenCodeInABox extends Sandbox {
  static outboundByHost = {
    "github.com": (request, env, ctx) => {
      const headersWithAuth = new Headers(request.headers);
      headersWithAuth.set("x-auth-token", env.SECRET);
      return fetch(request, { headers: headersWithAuth });
    }
  }
}

Any time code running in the sandbox makes a request to “github.com”, the request is proxied through the handler. This allows you to do anything you want on each request, including logging, modifying, or cancelling it. In this case, we’re safely injecting a secret (more on this later). The proxy runs on the same machine as any sandbox, has access to distributed state, and can be easily modified with simple JavaScript.

We’re excited about all the possibilities this adds to Sandboxes, especially around authentication for agents. Before going into details, let’s back up and take a quick tour of traditional forms of auth, and why we think there’s something better.

The core issue with agentic auth is that we can’t fully trust the workload. While our LLMs aren’t nefarious (at least not yet), we still need to be able to apply protections to ensure they don’t use data inappropriately or take actions they shouldn’t.

A few common methods exist to provide auth to agents, and each has downsides:

Standard API tokens are the most basic method of authentication, typically injected into applications via environment variables or in mounted secrets files. This is the arguably simplest method, but least secure. You have to trust that the sandbox won’t somehow be compromised or accidentally exfiltrate the token while making a request. Since you can’t fully trust the agent, you’ll need to set up token expiry and rotation, which can be a hassle.

Workload identity tokens, such as OIDC tokens, can solve some of this pain. Rather than granting the agent a token with general permissions, you can grant it a token that attests its identity. Now, rather than the agent having direct access to some service with a token, it can exchange an identity token for a very short-lived access token. The OIDC token can be invalidated after a specific agent’s workflow completes, and expiry is easier to manage. One of the biggest downsides of workload identity tokens is the potential inflexibility of integrations. Many services don’t have first-class support for OIDC, so in order to get working integrations with upstream services, platforms will need to roll their own token-exchanging services. This makes adoption difficult.

Custom proxies provide maximum flexibility, and can be paired with workload identity tokens. If you can pass some or all of your sandbox egress through a trusted piece of code, you can insert whatever rules you need. Maybe the upstream service your agent is communicating with has a bad RBAC story, and it can’t provide granular permissions. No problem, just write the controls and permissions yourself! This is a great option for agents that you need to lock down with granular controls. However, how do you intercept all of a sandbox’s traffic? How do you set up a proxy that is dynamic and easily programmable? How do you proxy traffic efficiently? These aren’t easy problems to solve.

With those imperfect methods in mind, what does an ideal auth mechanism look like?

Ideally, it is:

• Zero trust. No token is ever granted to an untrusted user for any amount of time.

• Simple. Easy to author. Doesn’t involve a complex system of minting, rotating, and decrypting tokens.

• Flexible. We don’t rely on the upstream system to provide the granular access we need. We can apply whatever rules we want.

• Identity-aware. We can identify the sandbox making the call and apply specific rules for it.

• Observable. We can easily gather information about what calls are being made.

• Performant. We aren’t round-tripping to a centralized or slow source of truth.

• Transparent. The sandboxed workload doesn’t have to know about it. Things just work.

• Dynamic. We can change rules on the fly.

We believe outbound Workers for Sandboxes fit the bill on all of these. Let’s see how.

First, we’ll look at a very basic example: logging requests and denying specific actions.

In this case, we’ll use the outbound function, which intercepts all outgoing HTTP requests from the sandbox. With a few lines of JavaScript, it’s easy to ensure only GETs are made and log then deny any disallowed methods.

class MySandboxedApp extends Sandbox {
  static outbound = (req, env, ctx) => {
    // Deny any non-GET action and log
    if (req.method !== 'GET') {
      console.log(`Container making ${req.method} request to: ${req.url}`);
      return new Response('Not Allowed', { status: 405, statusText: 'Method Not Allowed'});
    }

    // Proceed if it is a GET request
    return fetch(req);
  };
}

This proxy runs on Workers and runs on the same machine as the sandboxed VM. Workers were built for quick response times, often sitting in front of cached CDN traffic, so additional latency is extremely minimal.

Because this is running on Workers, we get observability out of the box. You can view logs and outbound requests in the Workers dashboard or export them to your application performance monitoring tool of choice.

How would we use this to enforce a zero trust environment for our agent? Let’s imagine we want to make a request to a private GitHub instance, but we never want our LLM to access a private token.

We can use outboundByHost to define functions for specific domains or IPs. In this case, we’ll inject a protected credential if the domain is “my-internal-vcs.dev”. The sandboxed agent never has access to these credentials.

class OpenCodeInABox extends Sandbox {
  static outboundByHost = {
    "my-internal-vcs.dev": (request, env, ctx) => {
      const headersWithAuth = new Headers(request.headers);
      headersWithAuth.set("x-auth-token", env.SECRET);
      return fetch(request, { headers: headersWithAuth });
    }
  }
}

It is also easy to conditionalize the response based on the identity of the container. You don’t have to inject the same tokens for every sandbox instance.

 static outboundByHost = {
  "my-internal-vcs.dev": (request, env, ctx) => {
    // note: KV is encrypted at rest and in transit
    const authKey = await env.KEYS.get(ctx.containerId);

    const requestWithAuth = new Request(request);
    requestWithAuth.headers.set("x-auth-token", authKey);
    return fetch(requestWithAuth);
  }
}

As you may have noticed in the last example, another major advantage of using outbound Workers is that it makes integration into the Workers ecosystem easier. Previously, if a user wanted to access R2, they would have to inject an R2 credential, then make a call from their container to the public R2 API. Same for KV, Agents, other Containers, other Worker services, etc.

Now, you just call any binding from your outbound Workers.

class MySandboxedApp extends Sandbox {
  static outboundByHost = {
    "my.kv": async (req, env, ctx) => {
      const key = keyFromReq(req);
      const myResult = await env.KV.get(key);
      return new Response(myResult);
    },
    "objects.cf": async (req, env, ctx) => {
      const prefix = ctx.containerId
      const path = pathFromRequest(req);
      const object = await env.R2.get(`${prefix}/${path}`);
      const myResult = await env.KV.get(key);
      return new Response(myResult);
    },
  };
}

Rather than parsing tokens and setting up policies, we can easily conditionalize access with code and whatever logic we want. In the R2 example, we also were able to use the sandbox’s ID to further scope access with ease.

Networking control should also be dynamic. On many platforms, config for Container and VM networking is static, looking something like this:

{
  defaultEgress: "block",
  allowedDomains: ["github.com", "npmjs.org"]
}

This is better than nothing, but we can do better. For many sandboxes, we might want to apply a policy on start, but then override it with another once specific operations have been performed.

For instance, we can boot a sandbox, grab our dependencies via NPM and Github, and then lock down egress after that. This ensures that we open up the network for as little time as possible.

To achieve this, we can use outboundHandlers, which allows us to define arbitrary outbound handlers that can be applied programmatically using the setOutboundHandler method. Each of these also takes params, allowing you to customize behavior from code. In this case, we will allow some hostnames with the custom “allowHosts” policy, then turn off HTTP.

class MySandboxedApp extends Sandbox {
  static outboundHandlers = {
    async allowHosts(req, env, { params }) {
     const url = new URL(request.url);
     const allowedHostname = params.allowedHostnames.includes(url.hostname);

      if (allowedHostname) {
        return await fetch(newRequest);
      } else {
        return new Response(null, { status: 403, statusText: "Forbidden" });
      }
    }
    
    async noHttp(req) {
      return new Response(null, { status: 403, statusText: "Forbidden" });
    }
  }
}

async setUpSandboxes(req, env) {
  const sandbox = await env.SANDBOX.getByName(userId);
  await sandbox.setOutboundHandler("allowHosts", {
    allowedHostnames: ["github.com", "npmjs.org"]
  });
  await sandbox.gitClone(userRepoURL)
  await sandbox.exec("npm install")
  await sandbox.setOutboundHandler("noHttp");
}

This could be extended even further. Your agent might ask the end user a question like “Do you want to allow POST requests to cloudflare.com?” based on whatever tools it needs at that time. With dynamic outbound Workers, you can easily modify the sandbox rules on the fly to provide this level of control.

To do anything useful with requests beyond allowing or denying them, you need to have access to the content. This means that if you’re making HTTPS requests, they need to be decrypted by the Workers proxy.

To achieve this, a unique ephemeral certificate authority (CA) and private key are created for each Sandbox instance, and the CA is placed into the sandbox. By default, sandbox instances will trust this CA, while standard container instances can opt into trusting it, for instance by calling sudo update-ca-certificates.

export class MyContainer extends Container {
  interceptHttps = true;
}

MyContainer.outbound = (req, env, ctx) => {
  // All HTTP(S) requests will trigger this hook.
  return fetch(req);
};

TLS traffic is proxied by a Cloudflare isolated network process by performing a TLS handshake. It creates a leaf CA from an ephemeral and unique private key and uses the SNI extracted in the ClientHello. It will then invoke in the same machine the  configured Worker to handle the HTTPS request.

Our ephemeral private key and CA will never leave our container runtime sidecar process, and is never shared across other container sidecar processes.

With this in place, outbound Workers act as a truly transparent proxy. The sandbox doesn’t need any awareness of specific protocols or domains — all HTTP and HTTPS traffic flows through the outbound handler for filtering or modification.

To enable the functionality shown above in both Container and Sandbox, we added new methods to the ctx.container object: interceptOutboundHttp and interceptOutboundHttps, which intercept outgoing requests on specific hostnames (with basic glob matching), IP ranges, and it can be used to intercept all outbound requests. These methods are called with a WorkerEntrypoint, which gets set up as the front door to the outbound Worker.

export class MyWorker extends WorkerEntrypoint {
 fetch() {
   return new Response(this.ctx.props.message);
 }
}

// ... inside your container DurableObject ...
this.ctx.container.start({ enableInternet: false });
const outboundWorker = this.ctx.exports.MyWorker({ props: { message: 'hello' } });
await this.ctx.container.interceptOutboundHttp('15.0.0.1:80', outboundWorker);

// From now on, all HTTP requests to 15.0.0.1:80 return "hello"
await this.waitForContainerToBeHealthy();

// You can decide to return another message now...
const secondOutboundWorker = this.ctx.exports.MyWorker({ props: { message: 'switcheroo' } });
await this.ctx.container.interceptOutboundHttp('15.0.0.1:80', secondOutboundWorker);
// all HTTP requests to 15.0.0.1 now show "switcheroo", even on connections that were
// open before this interceptOutboundHttp

// You can even set hostnames, CIDRs, for both IPv4 and IPv6
await this.ctx.container.interceptOutboundHttp('example.com', secondOutboundWorker);
await this.ctx.container.interceptOutboundHttp('*.example.com', secondOutboundWorker);
await this.ctx.container.interceptOutboundHttp('123.123.123.123/23', secoundOutboundWorker);

All proxying to Workers happens locally on the same machine that runs the sandbox VM. Even though communication between container and Worker is “authless”, it is secure.

These methods can be called at any time, before or after starting the container, even while connections are still open. Connections that send multiple HTTP requests will automatically pick up a new entrypoint, so updating outbound Workers will not break existing TCP connections or interrupt HTTP requests.

Local development with wrangler dev also has support for egress interception. To make it possible, we automatically spawn a sidecar process inside the local container’s network namespace. We called this sidecar component proxy-everything. Once proxy-everything is attached, it applies the appropriate TPROXY nftable rules, routing matching traffic from the local Container to workerd, Cloudflare’s open source JavaScript runtime, which runs the outbound Worker. This allows the local development experience to mirror what happens in prod, so testing and development remain simple.

If you haven’t tried Cloudflare Sandboxes, check out the Getting Started guide. If you are a current user of Containers or Sandboxes, start using outbound Workers now by reading the documentation and upgrading to @cloudflare/containers@0.3.0 or @cloudflare/sandbox@0.8.9.

Read more here: https://blog.cloudflare.com/sandbox-auth/

The post Dynamic, identity-aware, and secure Sandbox auth appeared first on IPv6.net.

It’s easy to think of blockchain as just for cryptocurrency, but that’s really not the whole story. This technology is quietly working behind the scenes in many different areas, making things work better and more securely. We’re going to look at some actual blockchain examples in real life that show how it’s changing things, from how we send money to how companies track their goods.

Key Takeaways

• Blockchain is being used in finance to make money transfers faster and cheaper, cutting out middlemen. JPMorgan Chase’s Onyx initiative and apps like Cash App are good examples of this.
• Supply chains are becoming more transparent thanks to blockchain. Companies like Oracle and DHL are using it to track goods better and reduce problems.
• Healthcare is seeing improvements in data management with blockchain. Platforms like BurstIQ and Nebula Genomics are helping secure patient information and give people more control over their health data.
• NFTs, powered by blockchain, are changing how we think about owning digital items. Things like NBA Top Shot moments and art on OpenSea show how creators and collectors can benefit.
• Beyond finance and digital items, blockchain is also being explored for government services, media rights, smart contracts, and securing the Internet of Things, showing its wide-ranging potential.

Revolutionizing Finance: Beyond Cryptocurrency Transactions

When most people hear “blockchain,” they immediately think of Bitcoin or other digital currencies. And sure, cryptocurrencies are a huge part of the story, but the technology’s impact on finance goes much, much deeper. We’re talking about fundamentally changing how money moves, how agreements are managed, and how financial institutions operate, all without needing a central bank or a traditional intermediary for every single step.

Streamlining Money Transfers with Blockchain

Think about sending money across borders. It can be slow, expensive, and involve a lot of different banks and fees. Blockchain offers a way to make this process much quicker and cheaper. By using a shared, digital ledger, transactions can be verified and settled much faster, often in near real-time. This cuts out a lot of the middlemen, which means lower costs for everyone involved. It’s not just about international wires, either; even domestic transfers can benefit from this increased efficiency.

JPMorgan Chase’s Onyx Initiative

JPMorgan Chase, a giant in the traditional banking world, isn’t just watching from the sidelines. Their Onyx initiative is a prime example of how big players are adopting blockchain. Onyx uses distributed ledger technology to build new products and services for financial institutions. They’ve even piloted programs for real-time settlement of U.S. dollar transactions between banks. This shows that blockchain isn’t just for startups; established financial powerhouses are seeing its practical value for improving core operations.

Cash App and Circle’s Fintech Innovations

On the fintech side, companies like Cash App and Circle are integrating blockchain in user-friendly ways. Cash App, known for its peer-to-peer payments, has also made it possible for users to buy and sell Bitcoin using the Lightning Network, a technology built on top of blockchain that allows for faster and cheaper transactions. Circle, on the other hand, focuses on bridging traditional and digital payments. Their platform uses stablecoins – digital currencies pegged to a stable asset like the U.S. dollar – to move money securely and quickly between digital currencies. This makes it easier for businesses to accept crypto payments and for users to manage their digital assets.

The core idea is to remove friction and add transparency to financial processes that have historically been slow and opaque. By leveraging blockchain, these companies are not just offering new ways to transact, but are also building more robust and efficient financial infrastructure for the future.

Here’s a quick look at how these innovations are changing things:

• Faster Settlements: Transactions can be completed in minutes or seconds, rather than days.
• Reduced Costs: Fewer intermediaries mean lower fees for both businesses and consumers.
• Increased Transparency: All parties can see the transaction history on the ledger, building trust.
• New Financial Products: Blockchain enables innovative services like stablecoin payments and easier access to digital assets.

Securing and Streamlining Supply Chains

The journey of a product from its origin to your doorstep is often complex, involving numerous companies, locations, and handoffs. This intricate web can lead to confusion, delays, and even loss of goods. Blockchain technology is stepping in to bring much-needed clarity and efficiency to this process.

Enhancing Transparency in Logistics

Imagine knowing exactly where your package is at every single moment, from the factory floor to the delivery truck. Blockchain makes this possible by creating a shared, unchangeable record of every transaction and movement. This means all parties involved – manufacturers, shippers, customs agents, and even the end consumer – can see the same, accurate information. This single source of truth drastically reduces disputes and makes it easier to spot problems before they become major issues. It’s like having a digital passport for every item, detailing its entire history.

Oracle’s Intelligent Track and Trace

Oracle has developed a system called Intelligent Track and Trace, which is built entirely on blockchain. This software gives businesses a clear view across different parts of their supply chain. It can help identify problems in how food is handled, keep an eye on the temperature of shipped goods, and track equipment as it moves. This level of detail helps companies manage their products better and respond quickly if something goes wrong.

DHL’s Digital Shipment Ledgers

DHL, a major player in global shipping, is using blockchain to create digital ledgers for its shipments. Think of it as a highly secure, tamper-proof logbook for every package. This helps maintain the integrity of the shipping process and provides a reliable record of all transactions. By adopting this technology, DHL is making its vast operations more transparent and trustworthy.

Transforming Healthcare with Secure Data Management

Healthcare is an area where data security and accessibility are incredibly important. Think about your medical records – they contain some of the most personal information about you. Keeping this data safe from unauthorized access and making sure it can be shared efficiently and securely between doctors, hospitals, and even researchers is a big challenge. Blockchain technology is starting to offer some really interesting solutions here.

Improving Data Access and Reducing Costs

One of the biggest promises of blockchain in healthcare is its ability to create a more unified and secure way to manage patient data. Currently, medical records are often scattered across different systems, making it hard for healthcare providers to get a complete picture of a patient’s health history. This can lead to duplicated tests, delays in treatment, and increased costs. Blockchain can help by creating a single, tamper-proof record that authorized parties can access.

• Secure Storage: Sensitive patient information, like medical histories and test results, can be stored on a decentralized ledger. This makes it much harder for hackers to access or alter records compared to traditional centralized databases.
• Interoperability: Blockchain can act as a bridge between different healthcare systems, allowing for better sharing of patient data with consent. This means your doctor could potentially access your records from a specialist’s office instantly.
• Cost Reduction: By streamlining data management and reducing the need for manual record-keeping and reconciliation, blockchain can help cut down on administrative overhead in the healthcare sector.

The potential for blockchain to create a single source of truth for patient data could significantly reduce errors and improve the quality of care.

BurstIQ’s LifeGraph Platform

Companies like BurstIQ are already building platforms to address these issues. Based in Englewood, Colorado, BurstIQ’s LifeGraph platform uses blockchain and artificial intelligence to manage sensitive health and life science data. It’s designed to keep data secure and comply with regulations like HIPAA. Beyond just security, the platform aims to help organizations find new insights within their data, which could lead to better health outcomes. This kind of innovation is key for making sure that sensitive information is handled responsibly while still being useful for medical advancements. You can find more about how companies are managing data security at fund managers cybersecurity.

Nebula Genomics for Personal Data Control

On the other side of the coin, blockchain is also giving individuals more control over their own health information. Nebula Genomics, located in San Francisco, California, is a great example. They use blockchain to let people manage and even monetize their genomic data. Imagine being able to grant specific researchers access to your genetic information for a study, while still owning and controlling that data yourself. Nebula Genomics uses secure, encrypted methods to keep this personal data safe, allowing individuals to participate in research on their own terms. This shift towards patient-centric data management is a significant step forward.

Empowering Creators and Consumers with NFTs

Establishing Ownership of Digital Assets

Non-fungible tokens, or NFTs, have really shaken things up, moving beyond just digital art. Think of them as unique digital certificates of ownership, recorded on a blockchain. This means you can truly own a digital item, like a piece of music, a video clip, or even a virtual collectible, and prove it. Before NFTs, owning digital stuff was tricky; copies were everywhere, and proving you owned the ‘original’ was almost impossible. NFTs change that by giving each digital item a distinct identity on the blockchain, making it verifiable and transferable.

This technology opens up new ways for creators to connect with their audience and for consumers to collect and trade digital goods. It’s like having a digital signature on a piece of art, but for anything digital. The blockchain acts as a public ledger, showing who owns what, and this record is very hard to tamper with.

NBA Top Shot’s Collectible Moments

One of the most visible examples of NFTs in action is NBA Top Shot. Developed by Dapper Labs in partnership with the NBA, this platform allows fans to buy and sell officially licensed video clips of memorable NBA plays. These aren’t just random videos; they are “moments” – like a spectacular dunk or a game-winning shot – that are tokenized as NFTs. Each moment is unique, with a limited number of editions available, making them collectible items. Fans can own a piece of basketball history, and the value of these moments can change based on player performance, rarity, and market demand. It’s a whole new way to engage with sports memorabilia.

OpenSea’s Vast NFT Marketplace

When you think about where to find a huge variety of NFTs, OpenSea often comes to mind. It’s one of the largest online marketplaces where people can buy, sell, and even create NFTs. You can find everything from digital art and music to virtual land and collectibles from various projects. OpenSea uses blockchain technology to manage these transactions, providing a platform where buyers and sellers can interact. With millions of items listed and billions of dollars in trading volume, it shows how much interest there is in digital ownership and collecting.

The ability to assign verifiable ownership to digital items is a significant shift. It means creators can directly monetize their digital work in new ways, and consumers can participate in a digital economy with a sense of true ownership and potential for value appreciation.

Enhancing Government Efficiency and Security

Governments worldwide are exploring blockchain technology not just for its potential to secure digital assets, but also to fundamentally improve how public services operate. Think about it: many government processes involve a lot of paperwork, verification steps, and potential for errors or even fraud. Blockchain offers a way to make these systems more transparent, reliable, and less prone to tampering.

Securing Government Documents and Processes

One of the most direct applications of blockchain in government is in securing important documents and records. By storing information like birth certificates, land titles, or professional licenses on a decentralized ledger, governments can create a permanent, unalterable record. This makes it incredibly difficult for anyone to forge documents or alter official records, which can significantly reduce identity theft and fraud. This immutable record-keeping is a game-changer for establishing trust in official documentation.

• Reduced Fraud: Makes it harder to create fake IDs or tamper with official records.
• Improved Verification: Simplifies the process of verifying the authenticity of documents.
• Increased Efficiency: Cuts down on manual checks and the need for physical archives.

The sheer volume of sensitive data handled by government agencies makes them prime targets for cyberattacks. Blockchain’s inherent security features, like cryptography and decentralization, provide a robust defense against unauthorized access and data breaches.

Blockchain-Based Voting Systems

Elections are a cornerstone of democracy, and ensuring their integrity is paramount. Blockchain technology presents an intriguing possibility for creating more secure and accessible voting systems. Imagine being able to cast your vote from a secure app, knowing that your ballot is recorded immutably and anonymously on a blockchain. This could potentially increase voter turnout, especially among those who find it difficult to get to polling stations, and provide a clear, auditable trail of every vote cast, making the entire process more transparent and trustworthy.

• Enhanced Security: Cryptographic methods protect against hacking and manipulation.
• Increased Accessibility: Allows for remote voting via secure digital platforms.
• Greater Transparency: Provides an auditable record of all votes cast.

Improving Bureaucratic Accountability

Bureaucracy can sometimes feel slow and opaque. Blockchain, particularly through the use of smart contracts, can introduce a new level of accountability. Smart contracts are self-executing agreements where the terms are written directly into code. In a government context, this could mean that certain processes automatically trigger when specific conditions are met, or that public officials’ actions are recorded transparently on the blockchain. This makes it easier to track progress, identify bottlenecks, and hold individuals or departments responsible for their commitments. It’s about making sure public funds and services are managed effectively and openly.

Innovations in Media and Intellectual Property

The media landscape is constantly changing, and with the rise of digital content, issues around ownership, piracy, and fair compensation have become more complex. Blockchain technology is stepping in to offer some much-needed solutions, bringing a new level of security and transparency to how creative works are managed and monetized.

Preventing Piracy and Preserving Ownership

One of the biggest headaches for creators is the unauthorized distribution and copying of their work. Digital files can be duplicated endlessly, making it hard to track who owns what and to ensure artists get paid for their creations. Blockchain offers a way to create a permanent, unchangeable record of ownership for digital assets. This immutable ledger acts as a verifiable proof of authorship, making it significantly harder for content to be pirated without detection. When content is registered on a blockchain, its origin and ownership are logged, and any subsequent transactions or licenses are also recorded transparently.

Kodak’s KODAKOne Platform

Kodak, a name long associated with photography, has ventured into the blockchain space with its KODAKOne platform. This system is designed to help photographers and other creators register their work. By logging images and other creative assets onto a blockchain, creators can establish a clear and indisputable record of ownership. This not only helps in preventing unauthorized use but also provides a framework for licensing and monetizing their work directly, cutting out many traditional intermediaries.

Pixsy’s Copyright Registration Tools

Pixsy is another company focused on protecting creators’ intellectual property. They offer tools that allow artists, photographers, and other creatives to register their work using blockchain technology. This process creates a timestamped, verifiable record of authorship. If a creator’s work is found to be used without permission, Pixsy can use this blockchain-backed evidence to help them claim their rights and seek compensation. It’s about giving creators more control and a stronger legal standing in the digital age.

The Rise of Smart Contracts and Decentralized Applications

Beyond just moving money around, blockchain technology has opened doors to automating agreements and building entirely new kinds of applications. This is where smart contracts and decentralized applications, often called dApps, come into play. Think of a smart contract as a digital agreement where the terms are written directly into code on the blockchain. When certain conditions are met, the contract automatically executes, removing the need for intermediaries and speeding things up considerably.

Automating Agreements with Blockchain

Smart contracts are a game-changer for how we handle agreements. Because they live on the blockchain, they are transparent, immutable, and self-executing. This means once a smart contract is set up, its terms are enforced automatically without anyone needing to oversee it. This can save a lot of time and reduce potential disputes. For example, imagine a real estate transaction where the payment is automatically released to the seller only when the digital deed is transferred to the buyer. No more waiting for banks or lawyers to process paperwork.

Here are some key benefits of using smart contracts:

• Automation: Tasks are executed automatically when predefined conditions are met.
• Trust: The code enforces the agreement, reducing reliance on third parties.
• Efficiency: Processes are faster and often cheaper due to the removal of intermediaries.
• Transparency: All parties can see the contract terms and execution on the blockchain.

Smart contracts bring a new level of certainty to agreements. They act like a digital notary and enforcer rolled into one, making sure that what was agreed upon actually happens, exactly as planned, without any room for human error or manipulation.

DFINITY’s Internet Computer

DFINITY’s Internet Computer is an ambitious project aiming to extend the functionality of the internet by hosting software directly on a decentralized network. It allows developers to build and deploy dApps and Web3 services without relying on traditional cloud infrastructure. The platform supports scalable smart contracts and offers fast transaction speeds, making it suitable for a wide range of applications, from decentralized social media to storing digital assets like NFTs.

Google’s Blockchain Node Engine

Google is also making its mark in the blockchain space with its Blockchain Node Engine. This service is designed to help businesses manage blockchain nodes more easily and efficiently. It streamlines the process of deploying smart contracts and relaying transactions, all supported by Google Cloud’s robust infrastructure. For companies looking to integrate blockchain technology without the heavy lifting of managing complex node operations, Google’s offering provides a more accessible path.

Google’s Blockchain Node Engine

Google is also making its mark in the blockchain space with its Blockchain Node Engine. This service is designed to help businesses manage blockchain nodes more easily and efficiently. It streamlines the process of deploying smart contracts and relaying transactions, all supported by Google Cloud’s robust infrastructure. For companies looking to integrate blockchain technology without the heavy lifting of managing complex node operations, Google’s offering provides a more accessible path.

Securing the Internet of Things (IoT)

The Internet of Things, or IoT, refers to the vast network of devices that connect to the internet, collecting and sharing data. Think smart thermostats, security cameras, even industrial sensors. While these devices offer incredible convenience and efficiency, they also present a growing security challenge. With so many connected gadgets, the potential for data breaches and unauthorized access increases significantly. This is where blockchain technology steps in, offering a robust way to protect these interconnected systems.

Protecting IoT Devices from Data Breaches

Blockchain’s inherent security features make it a strong candidate for safeguarding IoT networks. Its decentralized nature means there’s no single point of failure that hackers can target. Instead, data is distributed across many nodes, making it much harder to compromise. Furthermore, the immutability of blockchain records means that once data is recorded, it cannot be altered or deleted without consensus from the network, providing a clear audit trail and preventing tampering.

Xage’s Cybersecurity Platform for IoT

Xage Security is a company that has developed a blockchain-enabled cybersecurity platform specifically for IoT environments. Their solution focuses on managing multiple devices simultaneously, employing multi-factor authentication to verify device identities. A key feature is its self-healing capability, which can automatically address security breaches. Xage’s technology is finding use in industries like transportation, energy, and manufacturing, with notable clients including Microsoft, Dell, and the U.S. Air Force.

Helium’s People’s Network for Device Connectivity

Helium has built what it calls the “People’s Network,” a decentralized wireless network designed for IoT devices. It operates as a large-scale LoRaWAN network, enabling devices to connect and exchange information. This network allows for real-time tracking and reporting of asset data, which is useful for applications in smart agriculture, smart cities, and logistics. Interestingly, users can even earn cryptocurrency by setting up and running compatible hotspot devices, contributing to the network’s expansion.

The sheer volume of connected devices in the IoT landscape creates a complex attack surface. Traditional security models often struggle to keep pace with the rapid growth and diverse nature of these devices. Blockchain offers a new paradigm by distributing trust and security across the network itself, rather than relying on centralized authorities that can become bottlenecks or targets.

Here’s a look at how blockchain addresses IoT security concerns:

• Decentralization: Eliminates single points of failure, making it harder for attackers to disrupt the entire network.
• Immutability: Ensures that data logs are tamper-proof, providing a reliable history of device activity.
• Transparency: Allows for authorized parties to view transaction histories, aiding in the detection of suspicious behavior.
• Cryptography: Utilizes advanced encryption to secure data both in transit and at rest.

Looking Ahead: Blockchain’s Continued Journey

So, we’ve seen how blockchain is quietly working behind the scenes in many areas, not just in the world of digital money. From making sure your packages arrive on time and your medical records are secure, to proving you own that unique digital art piece, this technology is finding its footing in everyday life. It’s still early days for some of these applications, and there’s definitely a learning curve. But as companies continue to explore and build, we can expect blockchain to become an even more integrated, and perhaps even invisible, part of how things work. It’s less about the hype and more about the practical improvements it brings to transparency, security, and efficiency across the board.

Frequently Asked Questions

What is blockchain, and how is it used outside of digital money?

Think of blockchain as a super secure digital notebook that many people share. Instead of just keeping track of money like Bitcoin, this notebook can record all sorts of important information, like who owns what, or the steps a product takes from factory to store. It’s used in many areas to make things more honest, safe, and easier to track.

How does blockchain help businesses with their money transfers?

Sending money can sometimes involve many steps and fees. Blockchain helps by making these transfers faster and cheaper. It’s like cutting out the middlemen, so money can go from one place to another more directly and securely, saving companies time and money.

Can blockchain really make supply chains better?

Yes, it can! Imagine tracking a package. Blockchain can show exactly where a product has been, from the moment it was made to when it reaches you. This makes it harder for fake products to enter the system and helps everyone know that what they’re getting is real and has followed the right path.

How is blockchain used in healthcare?

In healthcare, keeping patient information safe and private is super important. Blockchain can help by storing this sensitive data in a way that’s very hard to hack. It also makes it easier for doctors and hospitals to share information when needed, while still protecting the patient’s privacy.

What are NFTs and how do they use blockchain?

NFTs, or Non-Fungible Tokens, are like digital certificates of ownership for unique items, like digital art or special moments in a video game. Blockchain makes sure that only one person can own a specific NFT, proving it’s the real deal and preventing copies from being passed off as the original.

How can blockchain make government services better?

Governments can use blockchain to make important records, like property deeds or voting information, more secure and harder to change by accident or on purpose. This can lead to fewer mistakes, more trust in government processes, and potentially make things like voting safer and more accessible.

The post Beyond Crypto: Unveiling Practical Blockchain Examples in Real Life appeared first on IntelligentHQ.

Read more here: https://www.intelligenthq.com/blockchain-examples-in-real-life/

The post Beyond Crypto: Unveiling Practical Blockchain Examples in Real Life appeared first on IPv6.net.

Designed by SmartHomeGuys in the UK, the DeskUp Pro is an ESP32-based standing desk controller compatible with Home Assistant, Homey Pro, and other Smart Home hubs, using the desk’s standard RJ11/RJ12 connection. Many modern standing desks come with a controller from Jiecang or another company featuring an RJ12 port. The DeskUp Pro plugs directly into this port, draws power without an external USB supply, and bridges the desk’s controls to your 2.4 GHz Wi-Fi network. This allows you to automate your desk height, set health-focused standing reminders, or use voice assistants like Google Home and Alexa, all while keeping the desk’s original physical keypad fully functional. DeskUp Pro specifications: MCU – Espressif Systems ESP32-C6 or ESP32-S3 microcontroller with 2.4GHz Wi-Fi and Bluetooth LE Desk connectivity – Built-in RJ11/RJ12 cable for data and power USB – USB Type-C port for initial setup and firmware flashing Misc Supported Jiecang control boxes JCB36NE2 (used […]

The post DeskUp Pro smart standing desk controller integrates with Home Assistant and Homey Pro Smart Home hubs appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/04/14/deskup-pro-smart-standing-desk-controller-integrates-with-home-assistant-and-homey-pro-smart-home-hubs/

The post DeskUp Pro smart standing desk controller integrates with Home Assistant and Homey Pro Smart Home hubs appeared first on IPv6.net.