Skip to main content
v1.0 — Zero dependencies, zero build step

The zero-dependency web platform.

A full-stack web platform — security-first, AI-native, zero dependencies. Reactive client, protocol server, autonomous agents, and a federated hub network — built with the freedom to build, ship and run your way.

Get Started Read the Docs
curl -fsSL https://cdn.weblisk.dev/install.sh | sh
0
Dependencies
<5KB
Core size (gzip)
100
Lighthouse score
52
Built-in modules
Why Weblisk

You don't need hundreds of outdated packages to build amazing websites

That's the whole reason Weblisk exists.

The Supply Chain Problem

Build a Next.js app and you inherit 180+ open source packages — each one a potential security exposure, breaking change, or abandoned repo. Nobody made a conscious choice to accept that risk. It just became the default.

The Security Reality

Supply chain attacks on npm are increasingly common. Maintainer burnout is documented. AI-generated code is flooding ecosystems with low-quality contributions. Every dependency is an attack surface you can't control.

The Browser Already Has It

The web platform has matured. ES modules, view transitions, the Navigation API, web components, import maps — the browser gives you everything you need natively. You just need a clean way to use it.

Weblisk is one framework, entirely our code. No bundler mixing server and client JavaScript. No node_modules folder. No npm audit showing 47 vulnerabilities in packages you didn't even know you had. Just a modern, clean, lightweight framework that gives you everything the browser has to offer — natively.
Features

Everything you need, nothing you don't

So what do you get when you strip away the dependency tree? A framework that's smaller, faster, and more secure — with 52 modules you import on demand.

Zero Dependencies

No npm install cascade. No node_modules. Just native ES modules and modern browser APIs you already know.

No Build Step

No Webpack, Vite, or Rollup. Write HTML, CSS, and JS — refresh the browser and it works.

Islands Architecture

HTML renders instantly. JavaScript loads only for interactive regions — true progressive enhancement.

Reactive Signals

Fine-grained reactivity without a virtual DOM diffing overhead. Change data, DOM updates surgically.

Security Built In

CSP headers, CSRF tokens, input sanitization, permissions policies — all native modules, not afterthoughts.

View Transitions

Native cross-document view transitions make multi-page navigation feel like a single-page app.

How it works

Reactivity without the ceremony

Islands are plain JavaScript functions. Import a signal, wire up an effect, and the DOM updates itself — no JSX, no template language, no framework boilerplate.

  • Works without JavaScript enabled
  • Hydrates on load, idle, visible, or media query
  • Each island loads independently — no global bundle
  • Full TypeScript definitions included
counter.js 
import { signal, effect } from 'weblisk';

export default function counter(el) {
  const [count, setCount] = signal(0);
  const btn = el.querySelector('button');

  btn.addEventListener('click', () =>
    setCount(count() + 1)
  );

  effect(() => {
    btn.textContent = `Count: ${count()}`;
  });
}
Just HTML

Two attributes. That's the entire API.

Point data-island at your script and choose when to hydrate. No config files, no routing tables, no provider wrappers.

  • Server-rendered HTML works before JS loads
  • Lazy hydration: load, idle, visible, media
  • Drop into any existing page — no rewrite needed
  • Works with any backend: Rails, Django, PHP, static
index.html 
<div data-island="/islands/counter.js"
     data-hydrate="visible">

  <h2>Live Counter</h2>
  <button>Count: 0</button>

</div>

<!-- That's it. No build. No bundle. -->
<script type="module"
  src="/weblisk/weblisk.js"></script>
Batteries included

Every module, built in

No npm install. No plugin ecosystem to navigate. It's all here, ready to import.

Client-Side Router

Navigation API interceptor upgrades MPA links to SPA-style content swaps. Prefetch via Speculation Rules.

State Management

Persistent key-value store with localStorage sync. Cross-tab reactivity via BroadcastChannel.

PWA & Offline

Service worker registration, install prompts, cache strategies, and background sync — all built-in modules.

Testing Utilities

DOM assertions, mock signals, mount helpers, and event simulation. Framework-native, no Jest or Vitest required.

Priority Scheduler

Yield to the main thread between tasks. Critical, high, normal, and low priorities keep your UI responsive.

Accessibility

Focus trapping, ARIA live regions, reduced-motion detection, and locale-aware Intl formatting — not an afterthought.

Performance Tooling

Web Vitals observer, lazy images, asset prefetching via Speculation Rules, and a render budget scheduler.

Web Workers

Move heavy computation off the main thread with a simple dispatch / onMessage worker bridge.

CLI Tooling

Scaffold, dev server, build with minification & fingerprinting, and update — one binary, no Node.js needed.

Blueprint-Driven DX

Describe your site as YAML declarations — pages, components, theme, conventions. Generate the entire codebase via AI. Zero hand-written boilerplate.

CDN-First Delivery

Import maps rewrite to your CDN at build time. Ship the framework from the edge — zero latency penalty.

Network Layer

Fetch wrapper with retries, timeouts, and request deduplication. Real-time via EventSource and WebSocket helpers.

DevTools Overlay

Activate with ?wl-debug — see island status, performance markers, and page meta at a glance.

Reactive

Signals that feel like plain variables

No decorators. No observables. No boilerplate. Create a signal, use it, and the DOM updates itself. Derived state and effects are just functions.

  • No virtual DOM overhead
  • Synchronous, predictable updates
  • Automatic dependency tracking
  • Memory-safe — cleaned up on disconnect
todo.js 
import { signal, computed, effect } from 'weblisk';

export default function todo(el) {
  const [items, setItems] = signal([]);
  const remaining = computed(() =>
    items().filter(t => !t.done).length
  );

  effect(() => {
    el.querySelector('.count')
      .textContent = `${remaining()} left`;
  });
}
Comparison

How Weblisk stacks up

See how Weblisk compares to popular frameworks on the things that matter.

Feature Weblisk Next.js Astro SvelteKit
Zero dependencies Yes 180+ 100+ 40+
No build step required Yes Required Required Required
Islands architecture Native No Yes No
Works without JS Yes Partial Yes Partial
TypeScript types Included Included Included Included
Security modules Built-in Add-on Add-on Add-on
PWA support Built-in Add-on Add-on Add-on
Core size (gzip) <5 KB ~90 KB ~30 KB ~15 KB
View transitions Built-in Add-on Built-in Add-on
Drop-in compatible Yes Own project Own project Own project
Server runtime Any Node.js Node.js Node.js
Deploy to Any host Node.js hosts Node.js / static Node.js hosts
Drop-in

Works with your existing stack

Weblisk doesn't replace your backend. Add it to any project with a single script tag.

Plain HTML

Static sites, landing pages, prototypes

Ruby on Rails

Drop into ERB templates

Django

Use in Django templates

PHP / Laravel

Add to Blade templates

Express / Node

Serve alongside any Node backend

Go / Gin

Static assets in Go backends

Beyond the Browser

A complete platform — client, server, agents, and a global network

Everything above is the client framework. But Weblisk is also a protocol-first server architecture, autonomous agents, and a federated hub network where organizations collaborate.

Server & Protocol

An open specification for lightweight servers. Define the protocol once — implement in Go, Rust, Python, or any language. Runtime-agnostic by design.

Blueprints

Declarative specifications for APIs, domains, and workflows. Define once, implement anywhere — no lock-in, no vendor coupling.

Agents

Autonomous services — SEO analysis, content quality, health monitoring, background sync, scheduled tasks. Sandboxed, portable, and AI-ready.

Hub

Every deployment is a self-sovereign hub. Hubs federate to form a global network — cryptographic data contracts, cross-org collaboration, EDI replacement.

Collaboration

Agents that work together across organizations

Traditional B2B integration requires EDI, middleware, and months of custom work. Weblisk hubs federate natively — agents collaborate across organizational boundaries with cryptographically enforced data contracts.

Self-Sovereign

Every hub owns its orchestrator, domains, agents, data, and policies. No central authority. No vendor lock-in. Your data never leaves your boundary.

Federated Trust

Ed25519 identity signing, behavioral fingerprinting, and data boundary contracts. Trust is verified, not assumed.

Domain Intelligence

Three free domains — SEO, Content Quality, and Health Monitoring — ship with every hub. Each domain coordinates specialized work agents.