Articles 23 to 26 build the same application with silverpoint in four frameworks: React with Next.js, Vue, Angular and Reflex. The three pages are the same, with the same data and the same checks in the browser. That makes it possible to compare them with numbers.

This article does not pick a winner. Every figure depends on decisions that are not silverpoint's: the bundler, server rendering or where the state lives. What is useful is knowing what each thing costs and why.

The Overview page of the Operations application in the four frameworks

At the top, React with Next.js and Vue. At the bottom, Angular and Reflex. They are real screenshots of each project, with the pointer on an hour of the hits chart. Reflex has one more chart, below what is visible: the response times, measured for real.

What each article builds

ArticleFrameworkProject
23React with Next.js 16App Router, Turbopack, prerendered pages
24Vue 3Vite and vue-router
25Angular 22CLI, router, standalone components and signals
26Reflex 0.11Python, with real response times measured by the backend

The three pages:

  • Overview. The dashboard with two indicators, the hits per hour live, the errors per hour linked by hour, the heatmap of errors by day and the donut of sales by channel. Below, the active hour and the button that downloads the hits chart as SVG.
  • Incidents. The 12 incidents from article 17 in a sortable, paginated table, with the modal to acknowledge them and the toast.
  • Settings. The alert rule form from article 16 and the theme: a palette and a cyanotype switch that change the whole application.

The three JavaScript ones use silverpoint 0.10.1. Reflex uses reflex-silverpoint-react 0.10.0, which brings its own copy of @silverpoint/react 0.10.0.

The same dashboard in four syntaxes

The Overview dashboard is the same component in all four. In React:

<Dashboard
  id="ops"
  title="Operations"
  description="Traffic, errors and sales of the web service today."
  layout={layout}
  link={{ key: 'hour' }}
  ground={settings.ground}
  palette={palette}
>

In Vue:

<SpDashboard
  id="ops"
  title="Operations"
  description="Traffic, errors and sales of the web service today."
  :layout="layout"
  :link="{ key: 'hour' }"
>

In Angular:

<sp-dashboard
  id="ops"
  title="Overview"
  description="Traffic, errors and sales of the web service, updated every 2 seconds."
  [layout]="layout"
  [link]="{ key: 'hour' }"
>

And in Reflex, the keyword arguments at the end of the call to dashboard(...):

id="ops",
title="Operations",
description="Traffic, errors and sales of the web service today.",
layout=LAYOUT,
link="hour",

Only React passes ground and palette to the dashboard. Since 0.10.0, the dashboard's frame follows the provider, as its charts do (silverpoint#17), so Vue, Angular and Reflex pass it nothing. In Next.js the two values are still needed for another reason: the overview is hidden when you change the theme in /settings, and without them its charts took about 2 seconds to take the new theme on return. Article 23 explains it.

How much code

Non-blank lines I wrote, comments included. The files each template generates do not count, nor does the series data, which is the same in all four:

React · Next.jsVueAngularReflex
Own code494466567609
With the data570542643670
Code files15121210

The four figures are close. What separates them:

  • Vue is the shortest. v-model works with every silverpoint control, and a module-level reactive() is enough as a store.
  • Angular writes the template and the styles inside each component, so its lines include them.
  • Reflex does a bit more: 46 lines measure the response times of three real sites with httpx, and the dashboard shows a seventh chart with them. Without that, it comes to about 560.
  • React splits the code between server and client components. Each page is a small server file that mounts a client component.
  • With 0.10, the three JavaScript ones lost code: the code that put the stylesheet inside the SVG and the rule that aligned the table are no longer needed. React went from 514 to 494 lines, Vue from 473 to 466 and Angular from 582 to 567. Reflex stayed the same: the lines it saved in the download it gained in the table rules for the production build.

The dependencies

Added on top of the template
React · Next.js@silverpoint/react, @silverpoint/core, @silverpoint/grounds, @silverpoint/fonts
Vuevue-router and @silverpoint/core
Angular@silverpoint/core
Reflexreflex, reflex-silverpoint-react and httpx

None needed a state library. In Vue and Angular, @silverpoint/core was already installed as a dependency of the adapter; it is declared because the application imports its palettes and its types.

How much it weighs

All the JavaScript of the production build, compressed with gzip. I convert every figure to kB (1000 bytes), because each project measured them with its own tool:

JS (gzip)CSS (gzip)Prerendered
React · Next.js245 kB16 kBYes, with the charts drawn
Vue97 kB16 kBNo
Angular161 kB15 kBNo
Reflex221 kB17 kBYes, with the charts drawn

What explains the differences:

  • Next.js carries its own router and React. With silverpoint 0.9.2 it weighed 327 kB: the provider was imported from the general entry of @silverpoint/react, which contains the 60 charts, and Turbopack did not drop the unused ones (silverpoint#21). With 0.10.1 it came down to 245 kB.
  • Vue with Vite drops the charts you do not use and splits each page into its own file. The first visit to / downloads about 98 kB with the CSS.
  • Angular loads each page separately with loadComponent. The first visit to / downloads about 157 kB with the CSS.
  • Reflex adds its state client and the socket that connects it to the backend.

The CSS is almost the same in all four: it is mostly the grounds' stylesheet and the components' one. The three EB Garamond fonts add another 75 kB.

How long it takes

On my machine, locally, without throttling the network. Median of three measurements:

Production buildDevelopment server, coldFirst chart ready (production)
React · Next.js7.6 s3.8 s until it serves the first page25 ms
Vue3.4 s0.3 s until ready288 ms
Angular4 s3.2 s until it serves the first page235 ms
Reflex3.7 s2.7 s until frontend and backend answer294 ms
  • Next.js's first chart arrives drawn in the HTML. Inside Dashboard, client charts get their size from the cell, so the static prerender draws them. Vue and Angular draw them in the browser. reflex export prerenders them too, except the response-time one, which waits for the backend; Reflex's 294 ms were measured with reflex run --env prod.
  • Vite starts almost instantly because it compiles nothing until you ask for a page. Its first page takes a little longer.
  • Reflex takes about 1 s to draw in development. In production it drops to 294 ms.

The figures are for comparing with each other, not a promise: on a real network size weighs more than local time. I measured them with silverpoint 0.9.2. With 0.10 I repeated them, and the difference between versions stayed within the noise of the measurement. The exception is the start of ng serve, a little faster because it prebundles the dependencies again.

Where the state lives

The theme and the ruleThe live windowWhen changing page
React · Next.jsA client context in the shared layoutAn interval in the pageNext keeps the last three pages hidden; the window pauses and resumes
VueA module-level reactive()An interval in the pageThe page unmounts; the window starts over
AngularRoot services with signalsA root serviceThe window keeps running
ReflexThe state on the server, per tabA background taskReflex cancels the task and launches it again on return

Next.js hides the pages you leave with display: none. Up to 0.9.2, in development their charts measured 0 px and warned with SP003 although nothing was wrong. Since 0.10.0, a hidden chart keeps its last width and does not warn (silverpoint#22).

The theme across the application

The provider colours silverpoint's charts and components, but not the page: it adds no element to the DOM. All four handle the page's background and text on their own, with the same --sp-* properties:

The provider that changesThe page background
React · Next.jsSilverpointProvider with values from the contextpaletteStyle as a style object
VueSilverpointProvider with reactive valuespaletteStyle on an element of its own
AngularIts own SILVERPOINT_CONFIG, with getters that read signalsThe ground's class and paletteStyle
Reflexsilverpoint_provider with state variablesColours computed in the state

Angular is the hard case: provideSilverpoint receives a fixed object. Article 25 solves it by providing SILVERPOINT_CONFIG with getters, something silverpoint's documentation does not cover.

The easiest and the hardest in each

The easiestThe hardest
React · Next.jsPrerendered pages with the charts drawn, and the state is kept when navigatingThe theme when coming back from a hidden page: the dashboard needs ground and palette so that its charts change together with the frame
Vuev-model on every control, aria-current for free on RouterLinkPainting the page in cyanotype, which has no palette of its own
AngularServices with signals as a store, [(open)] and [(value)] straight to the signalsThe theme in the provider: provideSilverpoint takes a fixed object
ReflexReal data with no API or CORS: the backend already existsEvery interaction is a round trip to the server, and rx.App(style=...) is not applied without RadixThemesPlugin

Two more silverpoint bugs showed up only in Angular, and 0.10.0 fixed both. Importing the stylesheet as text broke ng serve (silverpoint#19); now the stylesheet is imported from @silverpoint/grounds/styles-text. And the literal text title="…" stayed as an attribute on the element (silverpoint#18). It no longer does, although in Chrome the tooltip still appears: it comes from the SVG's <title> element, which is the chart's accessible name.

Which to choose

silverpoint does not decide for you: the 60 charts, the props and the components are the same in the four adapters, and the dashboard code changes only in syntax.

  • If your team already uses one of the four, stay with it. No difference in this table justifies switching frameworks for the charts.
  • If page weight matters above everything, Vue with Vite gave the smallest bundle.
  • If the first view has to arrive drawn, Next.js prerenders the charts inside a dashboard.
  • If the data is in Python, Reflex saves you writing an API: the dashboard reads the backend's state.

What comes next

Article 28 leaves the frameworks and works with AI assistants: silverpoint's MCP server and its skills, with real calls and outputs.