WildflowerJS Logo WildflowerJS

WildflowerJS Reactive JS, No BS*

A no-build reactive JavaScript framework, rooted in the web platform.
No build step. No dependencies. No lock-in.

Latest release: v1.3.0 · see what's new
<script src="wildflower.min.js"></script> ...and start building.

Back to Basics

The code you write is 100% web standard code. HTML stays HTML. JavaScript stays JavaScript. CSS stays CSS. No JSX, no templating language, no custom syntax to learn. If you know the web platform, you already know how to use WildflowerJS.

WildflowerJS extends the web platform. It doesn't replace it.

Your Development Simplified

Because you develop with 100% web standards, every tool in your existing chain already understands the code: IDE, browser DevTools, linter, formatter, screen reader, SEO crawler. Nothing to install, no custom file types, no sourcemaps. Save the file, refresh, and your change is live.

Just be a web developer.

Batteries Included: One Mental Model

Router, SSR, stores, computed properties, two-way binding, event modifiers, data pools, and TypeScript types, all built in, all speaking the same language. Learn data-bind once and you know binding everywhere: lists, pools, stores, forms. There's no five-library stack to keep in sync.

One script tag. Everything you need.

<div data-component="counter">
  <span data-bind="count"></span>
  <button data-action="increment">
    +1
  </button>
</div>

<script>
wildflower.component('counter', {
  state: { count: 0 },
  increment() { this.count++ }
})
</script>

How It Works

data-bind connects state to the DOM.

data-action connects events to methods.

this.count++ triggers a precise DOM update.

Mutate state. The DOM updates.

Two Reactivity Modes

data-list for automatic reactivity: mutate state, DOM updates. data-pool for explicit control: plain objects, zero proxy overhead, you say what changed.

Same template syntax. Different performance profile. From interactive forms to per-frame particle systems. You choose the right tradeoff for the job.

Try it. Right-click, inspect this demo. Every dot is a real DOM element.

See full demo →

Get Started View Demos
* Build Step

Zero Toolchain

Modern frameworks ask you to install a compiler, a bundler, a package manager, hundreds of fragile transitive dependencies, and a framework-specific file format, before you write a single line of your application.

WildflowerJS was built starting from a single principle: no build step, no tooling. Ever.

WildflowerJS asks you to add a script tag.

There's no CLI scaffolding step, no config files, no .vue/.jsx/.svelte source format. You don't debug through sourcemaps or wait on a build pipeline. Your project has zero dependencies.

Performance isn't a tradeoff. Build steps optimize bundle delivery, not the runtime work that follows it. WildflowerJS writes directly to the DOM, with no virtual DOM or reconciliation pass between state change and update, so it doesn't need a build step to be fast.

The framework is full-featured without the toolchain: router, SSR, stores, computed properties, transitions, pools. You don't need a toolchain to use any of it.

my-app/
  index.html
  app.js
  style.css
  wildflower.min.js

That's the entire project. No package.json.
No node_modules. No config files. Ship it.

Zero Install. Zero Attack Surface.

Every dependency you install is trust extended to a maintainer you've never met, running scripts on your dev machine and in your CI. A typical React + Vite + UI‑lib setup pulls in 300+ transitive packages before you write a feature.

Each one is a potential intrusion vector. NPM worms, OAuth chains compromising deploy platforms, postinstall hijacking: the supply chain is now where production code gets compromised, not the deploy. And signing isn't a backstop: Mini Shai‑Hulud (May 2026) compromised 170+ packages whose malicious versions carried valid SLSA Build Level 3 provenance, because the attestation came from build infrastructure the worm had already taken over.

WildflowerJS users don't have this attack surface, by construction. There is no npm install, no postinstall script, no transitive package graph. The framework is one file you copy or pin by hash.

As of v1.1, the same holds for building the framework itself. WildflowerJS bundles with a vendored rollup and terser pipeline pulled as three SHA‑512‑pinned tarballs: no npm install, no transitive packages, no postinstall scripts in the build path. The entire toolchain is three files verified by hash.

Zero dependencies is the absence of a problem the rest of the industry has not properly addressed.

A typical React/Vue project:

  npm install
  ├── hundreds of packages
  ├── from hundreds of maintainers
  ├── postinstall scripts run on install
  └── tens to hundreds of MB of transitive code

WildflowerJS:

  <script src="wildflower.min.js"></script>
  └── 1 file.
      No transitive dependencies.

Zero Compromise

WildflowerJS doesn't compromise performance for ease-of-use. Even with no build step, on the js-framework-benchmark, WildflowerJS performs at the level of frontier frameworks, level with the fastest signal-based frameworks across list creation, updates, selection, swaps, and removal. And for per-frame workloads, data pools lead every framework we tested in our Lorenz attractor simulation demo.

The charts here are the overall geomean standings and the operation breakdown from our latest full-field run, plus the sustained frame rate from our per-frame animation sweep. Click any chart to see it full size.

Delivery is fast too, because there's less to deliver. One file, no framework runtime split across chunks, no hydration pass. Lighthouse scores hold their own against compiled frameworks without a single build artifact.

Simplicity in the interface, performance in the implementation. WildflowerJS doesn't trade one for the other.

Benchmark setup for these charts: js-framework-benchmark operations 1 through 9, 15 samples per cell, all frameworks in a single run; total-duration medians, lower is better. The frame-rate chart runs each framework's fastest variant on the Lorenz attractor for 8 seconds per particle count, fullscreen on a 120 Hz panel; higher is better. Apple M5 Pro, 24 GB RAM, macOS 26.5.2, Google Chrome 150 (stable, headed).

Bar chart of geomean slowdown versus the fastest framework per operation, vanilla JS baseline 1.00: WF-pool 1.054, Vue Vapor 1.056, Solid 1.095, WF 1.120, Svelte 1.165, Vue 1.263. Lower is better.
Geomean slowdown vs fastest per operation. Lower is better.
Grouped bar chart of all nine js-framework-benchmark operations for Solid, Svelte, Vue, Vue Vapor, WF, and WF-pool, with per-operation rankings. WF-pool is fastest on most operations.
All nine operations, side by side. Stars mark the fastest.
Line chart of sustained FPS versus particle count on the Lorenz attractor for Solid, Svelte, Vue, Vue Vapor, WF, and WF-pool. WF-pool holds the highest frame rate at every count, staying above 60 FPS past 4500 particles.
Per-frame animation. Sustained FPS as particle count grows; higher is better.

Zero Lock-in

WildflowerJS works with the DOM, not instead of it. There's no virtual DOM intercepting your code and no compiler rewriting your markup. The render cycle is yours.

That means Leaflet, DataTables, Chart.js, D3, Three.js, any library that touches the DOM, just works. No wrapper packages or framework-specific escape hatches required. Drop in a script tag and use it.

Because your code is standard HTML and JavaScript, you're never locked in. Your skills transfer and your code is more portable. If you outgrow the framework, your knowledge doesn't expire.

This also means your "ecosystem" is all of the world of vanilla JS. Without compromises or hacks.

<!-- Use any library directly -->
<div data-component="map-view">
  <div id="map" style="height: 400px"></div>
</div>
wildflower.component('map-view', {
  state: { lat: 51.505, lng: -0.09 },
  init() {
    // Leaflet works as-is. No wrappers.
    this._map = L.map('map')
      .setView([this.lat, this.lng], 13);
    L.tileLayer('https://{s}.tile.osm.org'
      + '/{z}/{x}/{y}.png').addTo(this._map);
  }
})

Precise Reactivity

When you write this.count++, WildflowerJS updates the single DOM node bound to count. Nothing else is touched. There's no tree diffing or reconciliation pass to figure that out.

You get fine-grained updates and a simple mental model. Change a property, the bound element updates. That's the entire reactivity model.

Other frameworks ask you to learn signals, accessors, memos, effects, and subscription lifecycles to achieve what WildflowerJS does with a property assignment.

wildflower.component('dashboard', {
  state: {
    users: 1420,
    status: 'healthy'
  },
  computed: {
    summary() {
      return this.users + ' users, ' + this.status;
    }
  },
  refresh() {
    this.users = 1421;
    // Only the elements bound to 'users'
    // and 'summary' update. Everything
    // else on the page is untouched.
  }
})

One Reactivity Model. Everywhere.

Components, Stores, and Plugins all share the same reactive foundation. State, computed properties, and methods work identically no matter where they live. Learn it once, it works the same way in a UI component, a global store, or a framework plugin.

Other frameworks make you learn a different system for each layer. React components use hooks, but stores need Redux or Zustand, which are completely different APIs. Vue components use reactive data, but Pinia stores have their own patterns. Every layer is a new mental model.

In WildflowerJS, there's one model. A store is a component without a template. A plugin is an entity that extends the framework itself, adding directives, lifecycle hooks, and services. The same this.count++ triggers the same reactivity everywhere.

This unlocks patterns other frameworks can't express. A store can run headless physics simulations with tick(), feeding data into a component that renders it through a pool, all using the same reactive primitives, no glue code required.

// Component: reactive UI
wildflower.component('cart', {
  state: { items: [] },
  computed: {
    total() { return this.items.length; }
  }
})

// Store: global shared state
wildflower.store('user', {
  state: { name: '', role: 'guest' },
  computed: {
    isAdmin() { return this.role === 'admin'; }
  }
})

// Plugin: extends the framework
wildflower.plugin({
  name: 'notifications',
  state: { items: [], unreadCount: 0 },
  computed: {
    hasUnread() { return this.unreadCount > 0; }
  },
  add(msg) { this.items.push(msg); this.unreadCount++; }
})
// Access globally: wildflower.$notifications.add(...)

// Same state. Same computed. Same methods.

Live Server Data: Built In, Stays True

With WildflowerJS SSR, the page arrives already true. The server (your server, whatever back-end you prefer) renders your data into real HTML, so the first paint is real content, indexable and readable before a line of JavaScript runs. And because the markup is genuine HTML, hydration reads the page's state straight back out of the document. Server-rendered components end up exactly equivalent to client-rendered ones.

v1.3 brings data-query, which does for the rest of the page's life what SSR does for first load. Most frameworks hand you fetch() and leave the rest to you. There's an entire ecosystem of client data libraries that exists to fill that gap. WildflowerJS makes it a declaration instead. Name a source, point an element at it, say how fresh it should stay. Loading and error states, refresh on demand, request racing, and the whole refresh ladder (poll, conditional GET, focus, reconnect, server push) come with it. Oh, and there's no query language. Refinement is an ordinary computed property, and filtering happens client-side without a network round trip.

Together, Wildflower's SSR and data-query tell one story. The server renders the page with real data. Because hydration reads the page itself, there's no flash of empty content, no loading spinner over data the user can already see, and no hydration scripts locking up the main thread. The server's render is the actual UI. When paired with data-query, your SSR becomes the first result of a standing query. The query adopts that markup and keeps it updated from there.

And as you can see in the example, your markup is 100% HTML. From bean to cup, what you see is what you get.

<div data-component="product-board">
  <p data-show="$products.isLoading">
    Loading…
  </p>
  <p data-show="$products.error">
    Failed.
    <button data-action="retry">Retry</button>
  </p>

  <span data-bind="$products.count"></span>
  products

  <tbody data-query="products">
    <template>
      <tr>
        <td data-bind="name"></td>
        <td data-bind="stock"></td>
      </tr>
    </template>
  </tbody>
</div>
// The entire data layer:
wildflower.query('products', {
  from: '/api/products',
  key: 'id',
  refresh: ['focus', 'etag:60']
});

// Server-rendered page? Add data-ssr="true"
// and the markup the server sent becomes the
// query's first result. Live from there.

Data Pools

Every framework wraps collection items in reactive proxies, whether the item needs it or not. WildflowerJS gives you a choice: data-list for push reactivity (automatic), data-pool for pull reactivity (explicit control, zero proxy overhead).

Pools render plain objects with the same template syntax as lists. Mutate the object, call markDirty(), and only that item updates. Full CRUD, selection, bulk operations, all faster than the push-reactive path.

And because pools use pull-based rendering, they scale to simulations, games, particle systems, and data visualizations at native frame rate. Use cases that would choke a virtual DOM. No other framework has anything like this.

<div data-component="user-table">
  <tbody data-pool="users" data-key="id">
    <template>
      <tr>
        <td data-bind="name"></td>
        <td data-bind="status"
            data-bind-class="status === 'active'
              ? 'badge success'
              : 'badge inactive'"></td>
      </tr>
    </template>
  </tbody>
</div>
wildflower.component('user-table', {
  pools: { users: {} },

  init() {
    // Populate: plain objects, no proxies
    data.forEach(u => this.pools.users.add(u));
  },

  // Optional: add tick() and the same pool
  // renders every frame. Same template, same
  // data, different rendering frequency.
  // That's the only difference between a
  // display table and a particle system.
})

Built for AI-Assisted Development

Because WildflowerJS is standard HTML and JavaScript, AI code assistants already know how to write it. There's no custom syntax to hallucinate or compiler quirks to work around. The code an AI generates runs exactly as written, with no build step between generation and execution.

WildflowerJS ships an AI-optimized reference page with patterns, anti-patterns, and examples designed for code generation context windows. Our llms.txt file follows the llms.txt convention for machine-readable documentation.

And for structured app generation, our Universal App Manifest lets you describe an entire application as a JSON schema (components, state, computed properties, methods, templates) and have an AI generate the working code from the manifest, mediated through framework-specific idiom files.

You: "Build me a todo app with
WildflowerJS"

AI reads llms.txt or ai-assistant.html
     ↓
Generates standard HTML + JS
     ↓
<div data-component="todo-app">
  <input data-model="newItem">
  <button data-action="addItem">
    Add
  </button>
  <ul data-list="items">
    <template>
      <li data-bind="text"></li>
    </template>
  </ul>
</div>
     ↓
Open in your browser. It works, and you can read and understand the code.

Configuration

Configure WildflowerJS behavior through script tag attributes and runtime options.

Script Tag Configuration

WildflowerJS can be configured at load time using attributes on the script tag:

<!-- Default: Both data-* and data-wf-* prefixes work -->
<script src="wildflower.js"></script>

<!-- Exclusive mode: Only data-wf-* prefixes are processed -->
<script src="wildflower.js" data-wf-prefix="true"></script>

<!-- Enable debug mode -->
<script src="wildflower.js" data-debug="true"></script>

<!-- Set error handling strategy -->
<script src="wildflower.js" data-error-handling="throw"></script>

<!-- Disable auto-initialization (call wildflower.init() manually) -->
<script src="wildflower.js" data-auto-init="false"></script>
Script Attribute Values Description
data-wf-prefix "true" Only process data-wf-* attributes (ignore data-*)
data-debug "true" Enable debug mode with verbose logging
data-error-handling "log" | "throw" | "silent" Error handling strategy (default: "log")
data-auto-init "false" Disable auto-initialization; call wildflower.init() manually

Exclusive Prefix Mode

By default, WildflowerJS recognizes both standard data-* attributes and data-wf-* prefixed attributes. This dual-mode allows flexibility but can conflict with third-party libraries that also use data-action, data-bind, or similar attributes.

The Problem

Libraries like Bootstrap, Alpine.js, or custom JavaScript may use:

  • data-action - Common for delegated event handling
  • data-bind - Used by various binding libraries
  • data-toggle - Bootstrap modals, tooltips, etc.

When WildflowerJS processes these attributes, it may interfere with the intended third-party behavior.

The Solution: Exclusive Mode

Enable exclusive prefix mode to make WildflowerJS only process data-wf-* attributes:

<script src="wildflower.js" data-wf-prefix="true"></script>

With exclusive mode enabled:

  • data-wf-bind - Processed by WildflowerJS
  • data-wf-action - Processed by WildflowerJS
  • data-wf-list - Processed by WildflowerJS
  • data-bind - Ignored (available for third-party libraries)
  • data-action - Ignored (available for third-party libraries)
  • data-list - Ignored (available for third-party libraries)

Example: Using with Bootstrap

<!-- Enable exclusive mode to avoid conflicts with Bootstrap -->
<script src="wildflower.js" data-wf-prefix="true"></script>

<div data-wf-component="modal-example">
    <!-- Bootstrap uses data-toggle and data-target -->
    <button data-toggle="modal" data-target="#myModal">
        Open Bootstrap Modal
    </button>

    <!-- WildflowerJS uses data-wf-action -->
    <button data-wf-action="submitForm">
        Submit (WildflowerJS)
    </button>

    <!-- Display data with WildflowerJS binding -->
    <span data-wf-bind="username"></span>
</div>

Runtime Configuration

You can also toggle exclusive mode at runtime:

// Enable exclusive mode
wildflower.setWfPrefixMode(true);

// Disable exclusive mode (process both prefixes)
wildflower.setWfPrefixMode(false);

// Check current mode
console.log(wildflower.options.useWfPrefixOnly); // true or false
Note: Changing the prefix mode at runtime only affects newly processed elements. Existing bindings and contexts retain their original configuration.

Attribute Reference

The following table shows all framework attributes and their data-wf-* equivalents:

Core

Standard Attribute WF-Prefixed Description
data-component data-wf-component Component definition
data-action data-wf-action Event handler
data-external data-wf-external Preserve element during component HTML updates
data-cloak n/a Hide element until framework initializes (add [data-cloak] { display: none; } to CSS). Do not use inside list <template> elements.

Data Binding

Standard Attribute WF-Prefixed Description
data-bind data-wf-bind Text binding
data-bind-html data-wf-bind-html HTML binding (renders raw HTML)
data-bind-class data-wf-bind-class Dynamic class binding
data-bind-style data-wf-bind-style Dynamic inline style binding
data-bind-attr data-wf-bind-attr Dynamic HTML attribute binding (object expression)

Forms

Standard Attribute WF-Prefixed Description
data-model data-wf-model Two-way form binding
data-model-lazy data-wf-model-lazy Update on blur instead of input
data-model-event data-wf-model-event Custom event for model sync (for web components)
data-validate data-wf-validate Form validation

Conditionals & Lists

Standard Attribute WF-Prefixed Description
data-show data-wf-show Conditional display (CSS visibility)
data-render data-wf-render Conditional render (DOM insertion/removal)
data-list data-wf-list List rendering
data-key data-wf-key List item key property for efficient reconciliation

Components & Templates

Standard Attribute WF-Prefixed Description
data-props data-wf-props Component props (JSON format)
data-prop-* data-wf-prop-* Individual component prop
data-slot data-wf-slot Named slot content
data-use-template data-wf-use-template Use a named template from parent component
data-with data-wf-with Data context for configurable templates

Event Modifiers

These attributes modify the behavior of data-action handlers. See Event Handling for details.

Standard Attribute WF-Prefixed Description
data-event-prevent data-wf-event-prevent Call preventDefault()
data-event-stop data-wf-event-stop Call stopPropagation()
data-event-once data-wf-event-once Execute handler only once
data-event-self data-wf-event-self Only fire if event target is the element itself
data-event-outside data-wf-event-outside Fire when clicking outside the element
data-event-capture data-wf-event-capture Use capture phase
data-event-passive data-wf-event-passive Mark as passive listener
data-event-debounce data-wf-event-debounce Debounce handler (value in ms, default 300)
data-event-throttle data-wf-event-throttle Throttle handler (value in ms, default 300)
data-event-key-* data-wf-event-key-* Key modifiers (ctrl, alt, shift, meta, enter, etc.)

Advanced

Standard Attribute WF-Prefixed Description
data-portal data-wf-portal Render content at a different DOM location
data-transition data-wf-transition Animation for show/render changes
data-error-fallback data-wf-error-fallback Fallback content selector for error boundaries
data-ssr data-wf-ssr Mark component as server-side rendered

Developer Tools

Application Inspector

Call wildflower.inspect() from the browser console to get a snapshot of your running application:

wildflower.inspect()

This prints:

  • Components: a table of all active component types and their instance counts
  • Stores: each named store with its current state (expandable in devtools)
  • Summary: a one-line count, e.g. 3 components (14 instances), 2 stores

Example output:

[Wildflower] Application Inspector
  Components
┌─────────┬──────────────────┬───────────┐
│ (index) │    Component     │ Instances │
├─────────┼──────────────────┼───────────┤
│    0    │ 'product-card'   │    12     │
│    1    │ 'cart-drawer'    │     1     │
│    2    │ 'nav-bar'        │     1     │
└─────────┴──────────────────┴───────────┘
  Stores
    cart: {items: Array(3), total: 149.97}
    ui: {sidebarOpen: false, theme: 'dark'}
  Summary: 3 components (14 instances), 2 stores

The return value is an object you can work with:

const app = wildflower.inspect()
app.stores.cart         // { items: [...], total: 149.97 }
app.components          // { 'product-card': 12, 'cart-drawer': 1, ... }

Component Inspection

Pass a component name to inspect all instances of that type:

wildflower.inspect('kpi-widget')

This lists each instance with its DOM element and current state:

[Wildflower] Inspecting: kpi-widget (4 instances)
  #1 <div data-component="kpi-widget">
     state: {label: 'Revenue', value: 285644}
  #2 <div data-component="kpi-widget">
     state: {label: 'Orders', value: 1848}
  ...

The return value is the array of component instances, which you can use for further debugging:

const widgets = wildflower.inspect('kpi-widget')
widgets[0].element    // the DOM element
widgets[0].context    // the component's ContextProxy
Tip: inspect() works in all builds, including production. Store state objects and DOM elements are passed directly to the console so you can expand and drill into them in your browser's devtools.

Debug Mode

Enable verbose logging to see every binding, state change, and render cycle:

<script src="wildflower.js" data-debug="true"></script>

Debug mode outputs detailed information about:

  • Component registration and initialization
  • State mutations and computed recalculations
  • DOM binding and update cycles
  • Store subscriptions and notifications
Note: Debug mode produces significant console output. Use it during development to understand framework behavior, then disable it for production.

Best Practices

  • New projects: Use exclusive mode if you plan to integrate third-party libraries
  • Existing projects: Continue using standard data-* attributes unless conflicts arise
  • Migration: Both prefixes can be used simultaneously during gradual migration
  • Consistency: Pick one prefix style and use it throughout your project
Previous Common Mistakes
Next Third-Party JS Libraries