Vanilla JavaScript. Native browser APIs. A clearer way to build.

BUILD //
WITH THE WEB

Build modular interfaces that developers, teams, and AI assistants can understand and extend.

Explore

Simple To Learn
Clear To Extend
Ready To Grow

ModularCube.js is a lightweight frontend framework: a reusable foundation for the part of an application people see and use. It works with vanilla JavaScript, HTML, CSS, and native browser APIs.

Each feature is organized as a self-contained component with its own template, styles, configuration, and lifecycle. This makes the code easier to learn, review, reuse, and grow.

Because the structure is explicit and predictable, AI models can receive clearer project context and act as practical helpers for code generation, explanation, review, and routine development tasks—while people remain in control.

Component Template Styling Configuration

import { HTMLComponent } from '@modular-cube';
import config from './MyComponent.config.json' with { type: "json" };

export default class MyComponent extends HTMLComponent {
    // Define your variables
    
    // Called before the component is fully processed
    // Used to load configuration (HTML, CSS, behavior settings, etc.)
    async preProcess() {
        super.preProcess({ config });
    }
    
    // Called early in the component lifecycle
    // Can be used to set up initial properties or prepare internal state
    async toProcess() { 
        // Add early setup logic here
    }

    // Called after the component’s DOM has been created
    // Provides access to the shadow DOM for manipulation or event binding
    async atProcess(dom) { 
        // Add async logic here
    }
    
    // Enable your component config to call update every frame
    // Called every frame for continuous logic, animation, or state updates
    async inProcess(dom) {
        
    }
}
                
<!-- Text content interpolation -->
<p>Hello, ${this.word}!</p>

<!-- Attribute binding -->
<img alt="${this.title}"> 

<!-- Conditional class binding -->
<div class="card-${this.color}">...</div>

<!-- Inline style binding -->
<span style="color: '${this.color}';">Colored Text</span>

<!-- Rendered if color is "blue" -->
<divif="${this.color === 'blue'}">
    Blue
</div>
                
:host {
    --component-radius: ${this.borderRadius};
}

.card {
    border: 1px solid #ccc;
    border-radius: var(--component-radius);
    padding: 1rem;
    background: ${this.cardBackground};
}  
                
{
    "name": "MyComponent",
    "descripttion": "",

    "files": {
        "html": {
            "path": "./MyComponent.html"
        },

        "css": {
            "path": "./MyComponent.css"
        }
    },

    "behavior": {
        "apendToBody": false,
        "lazyLoading": false,
        "fps": 0,
        "debug": false
    }
}
                
~
kb
Approximate Core Runtime
%
Vanilla JavaScript + Browser APIs
Required Build Steps

Familiar Web Tools. A Stronger Component Model.

Use direct, readable patterns for templates, events, updates, styles, and component boundaries managed by the browser.

code
Template
Values
alt_route
Conditional
Rendering
format_list_bulleted
Dynamic
Lists
bolt
Event
Handling
visibility
Observable
Events
track_changes
Targeted
Updates
css
Scoped
Styles
blur_on
Shadow
DOM

One Workflow
For Every Project

Start, run, coordinate, and grow ModularCube.js applications from one clear workspace.

Project Setup
Start Command
Create a ready-to-run ModularCube.js project with less manual setup.
Local Runtime
Ports + Environments
Launch local services and keep ports and environments easy to see.
Workflow Coordination
Frontend + Backend
Coordinate development tasks across connected modules and services in one workflow.
Project Overview
Connected Projects
See related applications, services, and environments in one place.

Serve is the planned development companion for ModularCube.js. Its goal is to make full-stack work easier to start and easier to understand through guided setup, local runtime control, and a clear view of connected projects. The same predictable structure is intended to support AI agents with better context, helping them follow project conventions and handle repetitive development tasks while the developer keeps final control.

Coming Soon
Open to early collaborators and development partners.

Vanilla JavaScript
At The Core

MODULARCUBE.js RUNTIME
> loading browser APIs... > registering Custom Elements... > creating Shadow DOM boundaries... > importing ES Modules... > loading component HTML and CSS... > build step: none ✓ > compact runtime: ~30kb — virtual DOM: not required > direct DOM updates ready...
Fast
Project Setup
4
Clear Lifecycle Stages
100%
Browser-Standards Foundation
Modular
Application Architecture

Clear Value
For Every Contributor

Begin with the JavaScript, HTML, and CSS you already know.
— Developers
Familiar
Starting Point
Give every feature a predictable place, so teams can review and maintain it with less guesswork.
— Product & Engineering Teams
Predictable
Team Structure
Give AI assistants consistent files, lifecycle stages, and component boundaries to work from.
— AI-Assisted Teams
Context
Useful AI Support
Contribute to focused modules without first learning a large hidden runtime.
— Open-Source Collaborators
Focused
Contribution Surface
Build tools and services around open browser standards instead of a closed platform.
— Tooling & Platform Partners
Open
Integration Path
Support an approachable framework with a focused roadmap and room for ecosystem growth.
— Sponsors & Aligned Investors
Momentum
Growth Opportunity

Make Web Development Easier for People and AI

ModularCube.js starts from a practical belief: software should remain readable, explainable, and easy to change as it grows.

Clear by Design
Predictable components and explicit lifecycle stages show where each piece of code belongs.
AI-Ready Structure
Consistent files, configuration, and browser-based patterns give AI models useful project context.
Open for Collaboration
A standards-first foundation creates room for community tools, integrations, education, and partnerships.

AI is treated as a helper, not a replacement for developer judgment. The goal is to make routine work easier: explain a component, trace behavior, suggest a change, prepare tests, or scaffold a feature from clear project context.

By staying close to vanilla JavaScript and the browser, ModularCube.js aims to reduce lock-in, keep web skills transferable, and support applications that people can understand for the long term.

Clear Numbers
Practical Meaning

0
Lifecycle Stages
8
Core UI Capabilities
0
Virtual DOM Layers Required

Explore The
Component Model

Each part stays clear on its own while connecting to a larger application.

Drag to rotate · Hover to highlight a module

A practical frontend foundation with room for a shared ecosystem

school
Developers: familiar JavaScript, HTML, and CSS
account_tree
Teams: readable modules and clearer ownership
language
AI builders: predictable context for useful helper agents
open_in_full
Partners: opportunities for tools, services, and integrations
trending_up
Sponsors and investors: support the roadmap and ecosystem
Open for collaboration
Contributors, design partners, sponsors, and aligned investors are welcome
VANILLA JAVASCRIPT // NATIVE BROWSER APIS

BUILD
WITH
CLARITY

A frontend framework people and AI helpers can understand