CSS responds to screen size.
FVLA responds to behavior.
The first behavior-driven typography engine — presence, velocity, proximity and time unified into one living signal, computed off-thread through its own Cloudflare Worker. CSS never knew you were there.
CSS animates. FVLA perceives. Static breakpoints approximate — FVLA calculates. Your type knows where you are, how fast you moved, and how long you stayed. That's not CSS. That's never been CSS.
Every room runs the live engine. The signal follows you in. Move your cursor — each room shows a different axis of what FVLA can do.
Engine response curve, dimensional word wave, proximity-reactive grid, true multi-layer parallax, live metrics console, modular plugins, and viewport awareness — all live.
Proximity scaling on the FVD target box, FVDebugger badge with live metrics, animated grid background — the original FVLA showroom experience.
Full-viewport 3D perspective experience. Cursor drives the entire scene — reactive grid cells, depth layers, and live signal data flowing across the interface.
Engine oscilloscope, signal topology map, spectral frequency display, live terminal readout, and a voltage field — the signal visualised in every dimension.
FVSimpleScale puts the FV text scaling engine in your own project in under a minute. Get a free 24-hour trial key instantly from the worker — no account, no card.
The full FVLA typography engine on display — proximity scaling, velocity chromatics, time-driven breathing, and surge bursts across layered depth tiers.
Core client + your framework adapter. @lumenexus-fvla/fvla plus @lumenexus-js-framework/react (or vue, svelte, vanilla). One engine, your stack.
Presence, velocity, proximity, time, and surge — all read into one unified signal state and streamed off-thread to every section simultaneously.
Engine math runs inside a Blob Worker. Logic hidden, never readable in DevTools. Verified at runtime by your Lumenexus license key via Cloudflare.
Your adapter receives state, send, batch, ready — the same API surface across every framework. Main thread only writes. 60fps. No re-layouts.
Every section, every effect, every letter reads from the same living state. Presence, velocity, proximity, time, surge — continuous values, not binary hover.
How long you've been here. Builds slowly. Fades when you leave. CSS doesn't know you stayed.
Speed of movement. Letters lag and trail behind fast gestures. Momentum is real and continuous.
Pixel-level distance from cursor to each element's real bounding rect. Not :hover — a field.
Global phase. Organic rhythms, breathing cycles, slow environmental drift. Always running.
Sudden acceleration spike. Triggers ignition, glitch, and particle bursts across all sections simultaneously.
# Step 1 — install core + your adapter
npm install @lumenexus-fvla/fvla @lumenexus-js-framework/react
# or Vue, Svelte, Vanilla JS
npm install @lumenexus-fvla/fvla @lumenexus-js-framework/vue
npm install @lumenexus-fvla/fvla @lumenexus-js-framework/svelte
npm install @lumenexus-fvla/fvla @lumenexus-js-framework/vanilla
Every adapter exposes the same four values. Only the reactivity layer changes between frameworks — the engine underneath is identical.
import { useFVLA, FVLARenderer } from '@lumenexus-js-framework/react';
export default function App() {
const { state, send, batch, ready } = useFVLA(schema, {
licenseKey: 'FVLA-XXXX-XXXX-XXXX',
});
return <FVLARenderer schema={schema} state={state} send={send} batch={batch} />;
}
<script setup>
import { useFVLA } from '@lumenexus-js-framework/vue';
const { state, send, batch, ready } = useFVLA(schema, { licenseKey: 'FVLA-XXXX-XXXX-XXXX' });
</script>
<template>
<div v-if="ready"><!-- your reactive UI --></div>
</template>
<script>
import { useFVLA } from '@lumenexus-js-framework/svelte';
const { state, send, ready } = useFVLA(schema, { licenseKey: 'FVLA-XXXX-XXXX-XXXX' });
</script>
{#if $ready}
{#each schema as item}<button on:click={() => send(item.action)}>{item.label}</button>{/each}
{/if}
import { createFVLA } from '@lumenexus-js-framework/vanilla';
const { state, send, batch, subscribe } = createFVLA(schema, {
licenseKey: 'FVLA-XXXX-XXXX-XXXX',
});
subscribe((next) => {
document.getElementById('size-display').textContent = next.size;
});
One engine. One license key. Your framework of choice. The reactivity layer adapts — the signal intelligence underneath stays the same.
The main thread is a display layer. The engine is the brain. That separation is what makes FVLA feel different from everything that came before it — and why CSS will never catch up.
Each module slots into the FV engine without overhead. Composable, stable, and built for the Lumenexus architecture.
Proximity-based scaling with configurable falloff curves and easing profiles via the FV engine.
STABLEMulti-layer parallax with true Z-depth computation and perspective transform — no React hooks needed.
STABLEReactive subgrid layouts that reflow dynamically on viewport and state change — powered by the StratoStrate™ substrate. FVGrid is available in Bundle tiers.
STABLELive analytics: emit scale, distance, and velocity metrics from the FV engine to any downstream consumer.
BETAThe engine is modular by design. ScaleCore, DepthMap, GridEngine, FocusTrace — each one a discrete lens on the same living signal. Stack them. Compose them. The worker handles the rest.
FVSimpleScale puts the FV text scaling engine in your project in under a minute. Free 24-hour trial key, generated instantly by the Lumenexus worker. No account. No card. Just install, paste your key, and scale.
One key, verified at runtime by the Lumenexus worker. Agencies — the 5-Pack and 10-Pack cover multiple client domains at a single price.
One key. One worker. One runtime verification. Your domain is live the moment the key clears — no dashboards, no usage caps, no third-party SDK calling home.
Move your cursor. Feel the difference. Then build something CSS could never touch.
Each showroom demonstrates a different dimension of the FV engine — move your cursor and feel the difference.
Check if a license key is valid and see which tier it covers.
Focus View Lumenexus Absolute is a framework that helps developers create immersive web experiences using the Focus View browser engine. Built on the StratoStrate™ substrate, it keeps typography, spacing, and layout elements in balance across screen sizes without relying on stacks of media queries. Developers can scale text effortlessly and build interactive, responsive interfaces without getting buried in boilerplate code. Running server-side while delivering real-time visual feedback to the browser, Lumenexus makes it easy to see changes instantly, refine designs efficiently, and provide a seamless user experience on any device.
Questions, support, or enterprise licensing — reach out directly.
nicholis@mail.com