v1.0 Production Ready

PulsePoint

The backend-agnostic reactive engine. Keep your HTML, add fine-grained reactivity with a tiny runtime.

TodoApp.html
<style>
    .completed {
        text-decoration: line-through;
    }
</style>

<div>
    <form onsubmit="addTodo(event)">
        <input 
            type="text" 
            placeholder="New todo" 
            oninput="setNewTodo(event.target.value)" 
            value="{newTodo}" />
        <button type="submit">Add</button>
    </form>

    <ul>
        <template pp-for="todo in todos">
            <li key="{todo.id}">
                <input 
                    type="checkbox" 
                    checked="{todo.completed}" 
                    onchange="toggleTodo(todo.id, event.target.checked)" />
                <span class="{todo.completed ? 'completed' : ''}">{todo.text}</span>
                <button type="button" onclick="deleteTodo(todo.id)">Delete</button>
            </li>
        </template>
    </ul>
</div>

<script type="text/pp">
    const [newTodo, setNewTodo] = pp.state('');
    const [todos, setTodos] = pp.state([{
        id: 1,
        text: 'Sample task',
        completed: false
    }]);

    function nextId() {
        if (!todos || todos.length === 0) return 1;
        return Math.max(...todos.map(t => t.id)) + 1;
    }

    function addTodo(e) {
        e.preventDefault();

        const text = newTodo.trim();
        if (text === '') return;
        const item = {
            id: nextId(),
            text,
            completed: false
        };
        setTodos([...todos, item]);
        setNewTodo('');
    }

    function toggleTodo(id, checked) {
        setTodos(todos.map(t => (t.id === id ? {
            ...t,
            completed: checked
        } : t)));
    }

    function deleteTodo(id) {
        setTodos(todos.filter(t => t.id !== id));
    }
</script>

Browser-Resident State

Central state stays in the browser using pp.state, pp.effect.

Backend Agnostic

Works with Prisma PHP, Node, Go, Rust, C#, or Python. If it renders HTML, it works with PulsePoint.

Template-First Syntax

Use pp-for, pp-ref, pp-spread, pp-component directly in your markup. Zero JSX compilation step required.

Production Performance

Surgical updates hit only the DOM nodes that change. No VDOM overhead.

TypeScript Runtime

Strong typing for your state and helpers with a tiny production bundle size.

Drop-in Ready

Keep your current auth, routing, and ORM. Add PulsePoint only where you need interactivity.

Component Scope

Define components with pp-component. Pass props like isActive="{isActive}" with React-like scope isolation.

Portals & Composition

Advanced support for component composition and Portals. Easily render dialogs, toasts, or overlays outside the DOM tree.

Universal Components

Return compiled HTML from your backend and PulsePoint treats it as scoped components. Shared props flow from parent to server-rendered children automatically.

AI-native by design

Built for the AI era, not just the SPA era

PulsePoint keeps its runtime deliberately small and runs on plain HTML and native JavaScript. There are no custom file formats, no virtual DOM, and only a handful of primitives: pp-component, pp-spread, pp-ref, pp-for, plus pp.state, pp.effect, pp.ref.

Because everything is standard HTML and JavaScript, AI tools can read, generate, and refactor PulsePoint code without fighting a heavy DSL, compiler macros, or opaque lifecycle rules. What you see in the template is exactly what runs in the browser.

Native HTML & JS

PulsePoint works with the languages AI understands best out of the box: standard HTML templates and native JavaScript modules.

Tiny surface area

Only seven core primitives mean less to memorize for humans and fewer chances for AI to misapply framework-specific rules.

Transparent reactivity

Mustache bindings are tracked directly. AI can see exactly which state drives which part of the DOM—no virtual DOM or hidden diffing pipeline.

Backend-agnostic, AI-friendly

Any backend that renders HTML can host PulsePoint. AI can safely touch your templates and server code without breaking a fragile SPA pipeline.

Why it matters for AI

  • LLMs are trained heavily on HTML + JS, not on niche framework DSLs.
  • AI can generate PulsePoint components without needing a build step or special file format.
  • Refactors are safer: no hidden lifecycles, no mysterious rendering pipeline to break.
  • Frontend and backend stay in sync, so AI can reason about the full stack in one pass.
The Steel Ninja Code Logo

Jefferson Abraham

The Steel Ninja Code

thesteelninjacode@gmail.com

The Origin Story

From Prisma PHP to PulsePoint

PulsePoint was born from an ambitious experiment: Prisma PHP. The goal was simple yet challenging—to bring the modern, reactive experience of React and Next.js directly into the PHP environment.

Jefferson Abraham realized the potential to go even further: converting standard HTML into a complete, reactive programming language. What started as a PHP enhancement evolved into PulsePoint—a standalone, backend-agnostic engine.

Today, maintained by The Steel Ninja Code Team, PulsePoint is fully open source. It empowers developers to implement a JSX-like experience in any backend, proving that high-performance reactivity doesn't require a complex build step.