bQuery.js evolves from jQuery alternative to full-stack JavaScript framework

The landscape of JavaScript development has changed dramatically since jQuery’s heyday in the mid-2000s, but one developer refused to accept that its core value — simplifying browser inconsistencies — had disappeared entirely. Out of that reflection came bQuery.js, a project that began as a tribute to jQuery’s spirit but has since matured into a full-stack framework designed for 2025 and beyond.

The initiative’s evolution from humble beginnings to its new official home at bquery.js.org marks a significant milestone. This transition reflects not just a change in branding, but a fundamental shift in how developers can approach building modern web applications without sacrificing simplicity or performance.

The philosophy behind a modern web helper

When the original bQuery.js was conceived, its creator set out to answer a deceptively simple question: what pain points in today’s web development would a new library address, and how could it do so without introducing the very problems it aimed to solve? The answer led to three core principles that have remained non-negotiable throughout the project’s growth.

First, the library must eliminate any mandatory build step. Developers should be able to drop a single <script> tag into a plain HTML file and write functional, maintainable code in just a dozen lines. This means no reliance on node_modules, no bundler configurations, and no obscure toolchain dependencies that obscure the actual logic of an application.

Second, the API must remain consistent whether the code is loaded via npm or directly from a CDN. There are no separate editions for different distribution methods — just one import statement that behaves identically whether it pulls from an npm registry or a content delivery network.

Third, tree-shaking must be real, not theoretical. Importing bQuery should not bundle the entire framework into a developer’s project if they only need a single function like $. Every module exposes explicit entry points, ensuring developers pay only for the code they actually use.

These principles dictated the project’s direction from day one. They also created the foundation for bQuery.js to grow far beyond its original scope without accumulating technical debt.

From DOM helper to full-stack solution

The first release of bQuery.js looked exactly like what one might expect from a modern take on jQuery: a typed, chainable DOM helper that understood TypeScript types and required zero runtime dependencies. The code snippet below illustrates its simplicity.

import { $, $$ } from '@bquery/bquery/core';

$('#button').on('click', () => {
  $$('.card').addClass('hovered');
});

This minimal example worked exactly as promised — no build tool required, no configuration files, and a clear, intuitive API. Yet it was only the beginning.

The turning point arrived when signals were introduced to the project. Signals transformed $(‘#counter’).text(...) from a one-time DOM update into a reactive state expression. That shift unlocked an entirely new layer of functionality: components, routing, server-side rendering, and more — all while preserving the original commitment to simplicity and performance.

The framework’s growth did not happen by accident. Each new feature was added with the understanding that it must not break the three core promises. Developers who only wanted the DOM helper still received a lightweight library, while those building complex applications gained access to a rich ecosystem of tools.

Key additions include:

• Reactive primitives for managing state with signals and effects
• Native Web Components for building reusable components without virtual DOM overhead
• Declarative templates through directives like bq-on, bq-html-safe, and bq-memo
• Form handling with validation, dirty state tracking, and composable utilities
• Routing featuring lazy loading, navigation guards, and a useNavigation() composable
• Internationalization with locale negotiation, RTL support, and relative time formatting
• Accessibility helpers covering live regions, focus management, and reduced motion preferences
• HTTP utilities for polling, pagination, REST interactions, and WebSocket integration
• Drag-and-drop with sortable grids, keyboard navigation, and viewport constraints
• Server-side rendering supporting streaming, edge handlers, and response caching
• Server runtime equipped with middleware, cookies, streaming responses, and app.listen()

Each module maintains its own entry point, ensuring that importing only what you need keeps bundle sizes minimal.

Maintaining the promise through growth

The most remarkable aspect of bQuery.js’s evolution is not the breadth of features it has acquired, but the way it has preserved its original commitments despite that expansion. The framework remains accessible to developers who want nothing more than a modern DOM helper, while also catering to those building sophisticated applications.

This dual capability is evident in the way imports work. A minimal project can use only the core DOM utilities, while a complex application can import signals, components, routing, and server utilities — all with the same single import pattern and identical API surface.

// Minimal setup
import { $, $$ } from '@bquery/bquery/core';

// Reactive state management
import { signal, computed, effect } from '@bquery/bquery/reactive';

// Full-stack application
import { $, signal, component, registerDefaultComponents, defineBqueryConfig } from '@bquery/bquery';

The CDN distribution is not an afterthought; it is a core feature designed to serve developers who prefer to avoid build tools entirely. The following example demonstrates how a project can use bQuery.js directly from a CDN to create a reactive counter without any build step.

<script type="module">
  import { $, signal } from '
  
  const count = signal(0);
  
  $('#btn').on('click', () => count.value++);
  
  effect(() => $('p').text(`Count: ${count.value}`));
</script>

By refusing to compromise on its core principles, bQuery.js has evolved into something far greater than a library — it has become a framework that respects developers’ time, tooling preferences, and performance needs. As the web continues to evolve, this approach ensures that developers can focus on solving real problems rather than wrestling with toolchain complexities.

The future of bQuery.js lies in continuing to refine this balance — adding capabilities where they truly add value, while ensuring that simplicity remains the project’s defining characteristic.