DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
Announcing LightningChart JS 8.3: sunburst charts, multithreading, new dashboards


What is LightningChart JS?

LightningChart JS is a data visualization library for building high-end JavaScript charting applications in complex scenarios that demand high-performance data processing.

Introducing the Sunburst Chart

LightningChart JS introduces the sunburst chart, used for displaying hierarchical data as a series of aligned rings. LightningChart JS now makes it easier to explore part-to-whole relationships simultaneously across multiple levels.

Open this example online

Multithreading Performance Optimizations

Just when you thought that LightningChart JS could not get any faster, version 8.3 introduces Multi-threading Performance Optimizations as a built-in functionality to make your charts even snappier.

By using multi-threading, we were able to load an absolutely massive data visualization with 40 channels and 10 million data points each in just above 1 second. And you can zoom in/out/reload data without any lag.

JS Drill-Down Nord Pool Map Dashboard

Introducing the JavaScript Drill-Down Nord Pool Map Dashboard, which visualizes day-ahead market data from the Nord Pool energy exchange. It provides a geographic overview of the next day’s planned power generation across the Nordic-Baltic region.

Open this example online

Sunburst Chart Dashboard

Introducing the Sunburst chart dashboard, which combines a regional map with embedded sparkline-style charts, a sortable summary table with status indicators, a dual-axis chart pairing stacked columns with an overlaid line series on a shared time axis, and a row of toggle chips for filtering.

Open this example online

Other Improvements

LightningChart JS 8.3 comes with several more improvements, including:

Built-in axis zebra stripes
Out-of-the-box text color contrast improvements
Built-in chart opacity filter
Rectangle series histogram usability improvements

To see the full list of changes and improvements, visit the changelog, or read the official release note.

Get started with LightningChart JS 8.3 today

Start your 30-day free trial



Source link

I built an MCP server so AI agents can flash 1,000+ embedded boards


npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

That’s the install. Open a terminal anywhere — your laptop, a fresh VM, a coworker’s machine — type one line, and you get a React dashboard wired to PlatformIO Core. From there an LLM can compile firmware, flash it to a real board, and stream serial back to the same browser tab.

platformio-mcp v2.0.0 shipped to npm. Here’s why and how.

The gap

LLMs are stupidly good at writing firmware. Hand Claude a datasheet and it’ll spit out C++ that compiles. Hand it the FreeRTOS docs and it’ll wire up a queue without breaking a sweat.

The next step always falls apart.

“Great, now flash it to the ESP32 sitting on my desk.”

You get back a markdown wall of “first install pyenv, then bootstrap a venv, then pip install platformio, then check your USB-C cable supports data, then make sure the right udev rule is in place on Linux, then…” It’s a setup-doc generator. The agent has read every PlatformIO tutorial ever written. It still can’t push bytes to flash memory because it has no hands.

MCP is the hands. The agent calls a tool, the tool runs on your machine, the result comes back. PlatformIO Core is already a CLI that knows how to talk to ~1,000 boards across 30+ platforms (ESP32-S3, RP2040, STM32H7, nRF52840, ATmega328P, Teensy 4.1, SAMD21, ATtiny85, and so on). I exposed it through MCP. That’s the whole product.

What v2.0.0 actually does

Nine MCP tools. Each one is a thin wrapper around a pio subcommand:

list_boards → pio boards
init_project → pio project init
build_project → pio run (background mode + status polling)
upload_firmware → pio run –target upload (optional start_monitor)
list_devices → pio device list
serial_monitor → pio device monitor (non-blocking, streamed)
search_libraries → pio pkg search
install_library → pio pkg install
list_libraries → pio pkg list
get_dashboard_url → returns localhost URL with bound auth token

Enter fullscreen mode

Exit fullscreen mode

Plus init_project, the unsung hero. PlatformIO project scaffolding is the thing agents got wrong every single time before this — they’d hand-write a platformio.ini with three subtle bugs in the board_build section. The MCP tool just shells out to pio project init and the bugs vanish.

The demo that closes the deal

Real prompt, real ESP32, real flash:

> Initialize a new Arduino project for an ESP32 Dev Board in /tmp/esp32-blink.
Build it, flash it, and start the serial monitor.

Enter fullscreen mode

Exit fullscreen mode

The agent’s tool calls, in order:

list_boards { filter: “esp32” } → esp32dev
init_project { board: “esp32dev”, framework: “arduino”,
projectDir: “/tmp/esp32-blink” }
build_project { projectDir: “/tmp/esp32-blink” } → SUCCESS
upload_firmware { projectDir: “/tmp/esp32-blink”,
start_monitor: true } → flashed

Enter fullscreen mode

Exit fullscreen mode

End-to-end on a clean machine: ~90 seconds. Most of that is the PlatformIO toolchain pulling esptool and the Espressif SDK on first run. Subsequent flashes are sub-10s.

Install in one command

We make it easy to integrate PIO MCP into your choice of coding agent. v2.0.0 ships a one-shot installer:

npx platformio-mcp install –cline # Cline (VS Code extension or CLI)
npx platformio-mcp install –claude # Claude Desktop
npx platformio-mcp install –vscode # VS Code native MCP support
npx platformio-mcp install –antigravity # Google Antigravity

Enter fullscreen mode

Exit fullscreen mode

Each installer:

Resolves the host’s config path per OS. macOS goes to ~/Library/Application Support, Windows reads %APPDATA%, Linux falls back to ~/.config. There’s a 9-line appDataDir() helper that does the dispatch.
Reads the existing config if one’s already there.
If the JSON is corrupted, copies it to .bak before rewriting. I learned this the hard way.
Idempotently merges an mcpServers.platformio block. Re-running the installer is a no-op.
Prints the path it touched so you can grep for it later.

For any other MCP host, this is the manual config block:

{
“mcpServers”: {
“platformio”: {
“command”: “npx”,
“args”: (“-y”, “platformio-mcp”, “–open-dashboard-on-start”)
}
}
}

Enter fullscreen mode

Exit fullscreen mode

The dashboard

The dashboard is the part nobody asks for and everybody uses once they have it.

Reason: build output is the worst possible thing to feed back to an LLM. A clean pio run for an ESP32 project is 40+ kilobytes of toolchain noise — arm-none-eabi-gcc flags, linker incantations, every single .o file. Pour that into the agent’s context and you’ve spent a third of your token budget on text the agent doesn’t need.

So the MCP tools return short, structured summaries to the LLM. The full output streams over Socket.io to a React dashboard the human can watch:

A per-process random UUID is injected as PORTAL_AUTH_TOKEN at boot. Every HTTP request and every Socket.io connection requires it. The dashboard URL looks like http://localhost:8080?token= and that token isn’t in any config file or env var the LLM has access to. If you launch the dashboard, only you (and the agent that spawned it) can hit the API.

The auto-launch is gated behind –open-dashboard-on-start (or the PIO_MCP_OPEN_DASH_ON_START=true env var). Browser launch goes through the open package, so the same call works on macOS, Linux, and Windows. The previous version had a hardcoded exec(‘open …’) that only fired on macOS — patched in v2.0.0.

Things I’m proud of that nobody will notice

The tarball is 499 kB. 114 files. build/ + web/dist/ + scripts/installers/ + LICENSE + README. No node_modules, no tests, no web/src/. The minified UI bundle is 921 kB / 291 kB gzip on its own; everything else is rounding error.

prepublishOnly runs the full TypeScript build, the Vite UI build, and a smoke check that asserts build/index.js, web/dist/index.html, and scripts/installers/index.js exist before npm allows the publish to proceed. Hard to ship a broken artifact.
Workspace state is mediated through proper-lockfile. Two agent processes can’t race each other on the same project. If you’ve ever had two MCP servers fight over the same serial port, you know why this matters.
The pio-mcp alias package is 842 bytes. Three files: a 283-byte bin.js that does import(“platformio-mcp”), a package.json with one dependency, a README. Same binary, shorter to type.
The default npx platformio-mcp (no subcommand) still boots the MCP stdio server. Existing configs that point at build/index.js keep working unchanged. v2 is additive.

Get started in five seconds

# Open the dashboard right now. No clone, no build, no install.
npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

# Wire it into your AI agent of choice.
npx platformio-mcp install –cline
npx platformio-mcp install –claude
npx platformio-mcp install –vscode
npx platformio-mcp install –antigravity

Enter fullscreen mode

Exit fullscreen mode

Repo: github.com/jl-codes/platformio-mcpnpm: platformio-mcp · pio-mcpRelease notes: v2.0.0

I’m @forkbombETH on X. Issues and PRs welcome on GitHub. If you build something cool with this, lmk.

npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

A huge warm thank you to Matt Mcneill for being an amazing collaborator and pushing for the features that make v2 amazing!



Source link

Shopify Speed Optimization with Liquid Code (5 Patterns)



I audited 14 Shopify themes last quarter for speed. 11 of them blamed apps. None had touched Liquid loop count, capture-in-loop allocations, or image output.

After optimizing 100+ Shopify stores over 12 years: the code-level patterns in your theme files account for 40-60% of total render time. Apps matter. Images matter. The template layer is where the compounding problems live.

Here are the 5 Liquid patterns that move the needle.

1. Drop capture from loops

assign stores a value. capture renders a full block and stores it as a string. Using capture inside a loop means a new string allocation on every iteration.

Slow — 48 allocations on a 48-product collection:

{% for product in collection.products %}
{% capture product_card %}

{{ product.title }}
{{ product.price | money }}

{% endcapture %}
{{ product_card }}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Fast — direct output, zero allocations:

{% for product in collection.products %}

{{ product.title }}
{{ product.price | money }}

{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Use capture only when you need a reusable HTML block built once and output in a different location.

2. Cap nested loops with limit and {% break %}

Nested loops are the single biggest source of Liquid render time problems.

Slow — 2,500 iterations on a featured collections section:

{% for collection in collections %}
{% for product in collection.products %}
{% for image in product.images %}
{{ image | image_url: width: 300 }}” alt=”https://dev.to/mdkaspianfuad/{{ image.alt }}”>
{% endfor %}
{% endfor %}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Fast — 32 iterations, using featured_image and limit:

{% for collection in collections limit: 4 %}
{% for product in collection.products limit: 8 %}
{% if product.featured_image %}
{{ product.featured_image | image_url: width: 300 }}”
alt=”https://dev.to/mdkaspianfuad/{{ product.featured_image.alt | default: product.title }}”
width=”300″ height=”300″ loading=”lazy”>
{% endif %}
{% endfor %}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Use {% break %} to stop early once you have the N items you need. Use {% continue %} to skip non-matching items without a nested if.

Real result: Factory Direct Blinds went from 4,800 collection iterations to 216. LCP dropped from 22s to 2.7s.

3. Output images with image_tag (srcset + dimensions)

This single change can improve LCP by 500ms+ on collection pages.

Slow — no srcset, no dimensions, no lazy loading:

{{ product.featured_image | image_url: width: 800 }}”>

Enter fullscreen mode

Exit fullscreen mode

Fast:

{{ product.featured_image | image_url: width: 800 | image_tag:
srcset: “200,400,600,800”,
sizes: “(max-width: 768px) 100vw, 400px”,
loading: “lazy”,
decoding: “async”,
alt: product.featured_image.alt | default: product.title,
width: 800,
height: 800
}}

Enter fullscreen mode

Exit fullscreen mode

Critical: Your hero and first visible product image should use loading: “eager”, not lazy. Lazy-loading your LCP element is one of the most common speed mistakes I see on audits.

To handle this in a grid, conditionally eager-load the first 4:

{% for product in collection.products limit: 24 %}
{% assign img_loading = forloop.index 4 | iif: “eager”, “lazy” %}
{{ product.featured_image | image_url: width: 600 | image_tag:
loading: img_loading,
width: 600,
height: 600
}}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

4. Preload hero image and critical font in theme.liquid

{% if template == ‘index’ %}
{% assign hero_image = section.settings.hero_image %}
{% if hero_image %}
{{ hero_image | image_url: width: 1200 }}”
imagesrcset=”https://dev.to/mdkaspianfuad/{{ hero_image | image_url: width: 600 }} 600w, {{ hero_image | image_url: width: 1200 }} 1200w”
imagesizes=”100vw”>
{% endif %}
{% endif %}

{{ ‘your-heading-font.woff2’ | asset_url }}” crossorigin>

Enter fullscreen mode

Exit fullscreen mode

Wrap third-party preconnects in conditionals so they only fire when the feature is enabled:

{% if settings.enable_reviews %}

{% endif %}

Enter fullscreen mode

Exit fullscreen mode

5. Push dynamic content onto the Section Rendering API

Instead of a full page reload to update one section, fetch just that section’s HTML.

Slow — full page reload on filter click:

window.location.href = newUrl;

Enter fullscreen mode

Exit fullscreen mode

Fast — Section Rendering API:

async function updateCollection(url) {
const sectionId = ‘collection-grid’;
const response = await fetch(`${url}?sections=${sectionId}`);
const data = await response.json();
document.getElementById(sectionId).innerHTML = data(sectionId);
}

Enter fullscreen mode

Exit fullscreen mode

Response size drops from 100KB+ to 5-15KB. Perceived load time drops from 2-3 seconds to 200-400ms.

Good candidates: collection filtering, cart drawer, product recommendations, quick-view modals.

Before and after numbers

Store
Metric
Before
After

WD Electronics
Mobile LCP
9.3s
3.1s

WD Electronics
Lighthouse
41
72

WD Electronics
DOM Elements
4,200+
1,100

Factory Direct Blinds
Mobile PageSpeed
38
81

Factory Direct Blinds
LCP
22.0s
2.7s

Factory Direct Blinds
Liquid Render
840ms
65ms

Both stores saw measurable conversion improvements within 30 days of deploying the speed fixes.

How to verify in 5 minutes

Install the Shopify Theme Inspector Chrome extension. Open DevTools, go to the Shopify tab, reload your slowest collection page. Total Liquid render time should be under 100ms. Over 200ms means a section is bleeding render budget.
Open PageSpeed Insights on Mobile. Read Field Data first — that is real Chrome users, the metric Google ranks on.
Check Search Console > Experience > Core Web Vitals for which URL groups are flagged Poor.

The full post (with more code and the FAQ section) is at kaspianfuad.com.

If you want a professional audit of your theme’s Liquid performance, I run a Shopify speed-focused CRO audit that covers every pattern above plus the JS and third-party script layer.



Source link