J Javelle Start building

v1.0 · JVM 21 · Status Nominal

The new Java experience

Javelle is the new front of Java. Javelle is
the new front
of Java.

Java, beautifully reactive. Javelle brings Vue-like speed, Javelle-style application modes, server-rendered templates, routing, state, forms, i18n, native plugins, UI assets, and testing into one coherent JVM workflow.

Run the demo Read the dev guide
./bin/javellecreatemy-app
web pwa mobile desktop ssr
7delivery targets shipping
41built-in CLI commands
17handbook doc pages
170test files across modules

The name

Javelle means "the new Java experience."

Javelle is a coined brand name built from Java and nouvelle, the French word for new. The ending gives it a light, elegant, framework-like sound.

Java + nouvelle

A new, elegant way to build Java applications.

The name also carries the energy of "javelin": fast, sharp, and direct. That makes Javelle feel Java-first, modern, and precise without losing the elegance implied by -velle.

Java The language, ecosystem, and JVM confidence.
Nouvelle French for "new": the modern product direction.
-elle A lighter, elegant sound for a developer framework.

The idea

A framework shape familiar to frontend teams, expressed for JVM teams.

Javelle is designed around a practical goal: keep page structure, routing, modules, UI assets, and server-rendered behavior close to Java code while preserving the ergonomics developers expect from modern frontend tooling.

Components

Small Java classes, external HTML templates.

Pages and components use annotations such as @Component, @State, and @Template. Larger markup lives in matching .html files, keeping Java code focused.

Workflow

CLI-first app scaffolding.

The CLI creates apps, pages, layouts, boot files, stores, services, modules, modes, UI styles, icon packs, fonts, and build manifests with predictable project paths.

Runtime

Server-rendered foundation with browser-ready paths.

The current implementation focuses on MVC rendering, template parsing, routing, reactive state, forms, i18n, stores, plugins, testing, DevTools events, Studio inspection, and static dev-server delivery.

Developer quick start

From repository to browser in one local workflow.

Use the demo script for a complete generated app, or use the CLI commands directly when creating a new project.

Run the full demo 
mvn install
./scripts/dev-demo.sh --clean --port 3000
1

Install the reactor

Build and install the local modules so generated apps can resolve Javelle dependencies.

2

Create or refresh the demo app

The script scaffolds pages, modules, modes, UI assets, icons, fonts, and history routing.

3

Open localhost

The dev server serves resources, exposes config endpoints, and supports history fallback.

Create an app manually 
./bin/javelle create my-app --package app
cd my-app
../bin/javelle doctor
../bin/javelle mode add all
../bin/javelle ui add
../bin/javelle ui preset material
../bin/javelle mode routing web history --fallback
../bin/javelle build --mode web
../bin/javelle test
../bin/javelle dev --mode web --port 3000
Generate app pieces 
../bin/javelle generate page Dashboard
../bin/javelle generate component UserCard
../bin/javelle generate store Auth
../bin/javelle generate service User
../bin/javelle generate boot Auth
../bin/javelle generate layout Main
../bin/javelle generate module billing
../bin/javelle module enable billing

Developer documentation

The docs surface area a Javelle app needs.

The page is organized like a developer handbook: start with concepts, then move into commands, templates, runtime modules, UI, and validation.

Start

Project setup

How to create, build, run, and inspect a Javelle application.

  • Maven reactor
  • CLI launcher
  • Dev server
Build

CLI workflow

Commands for generators, modes, modules, themes, icons, and fonts.

  • generate page
  • mode routing
  • ui preset
Runtime

Templates and routing

Vue-style syntax on the JVM with route matching and not-found pages.

  • interpolation
  • v-if and v-for
  • history and anchor
Quality

Testing & diagnostics

170 test files across 30 modules, plus javelle test and javelle doctor for one-shot validation and environment checks.

  • javelle test
  • javelle doctor
  • GitHub Actions CI

Javelle Studio

DevTools for seeing what Javelle sees.

Studio is the inspection layer for reactive events, effects, computed values, component activity, route changes, plugins, permissions, logs, performance marks, and redacted debug reports. It ships through the CLI and the VS Code extension.

Javelle Studio connected
Signals 42
Effects 9
Errors 0
runtime signal.updated cartItems
runtime computed.evaluated cartTotal
plugin plugin.resolved Storage.save
router route.changed /checkout
Open Studio 
./scripts/devtools-studio.sh --port 8097
Attach runtime events 
JavelleDevTools.enable(DevToolsConfig.builder()
    .appName("MyApp")
    .environment("development")
    .build());
JavelleDevTools.serveWebSocket(8098, "local");
Export redacted report 
./scripts/export-devtools-report.sh --output debug-report.zip
Protocol

Stable event stream

Runtime hooks emit events like signal.updated, effect.finished, plugin.failed, and performance.mark.

Security

Local and redacted by default

Studio runs on localhost, production instrumentation stays off unless explicitly enabled, and debug reports mask tokens, cookies, passwords, keys, and sessions.

IDE

VS Code launches Studio

The extension adds commands to open Studio, inspect the active component, show the dependency graph, and export a debug report from the command palette.

Architecture

A layered stack instead of a bag of integrations.

Javelle separates core annotations, runtime rendering, UI assets, app structure, target modes, and testing into focused Maven modules.

Core model

Annotations and runtime contracts: components, templates, boot files, modules, state, props, and lifecycle hooks.

Runtime services

Template renderer, MVC page rendering, router, forms, stores, i18n, plugins, native bridge, SpringFabric AXIS dispatch, and test harness.

UI and assets

Component registry, CSS utilities, Material preset, themes, icons, fonts, accessibility, motion, and SCSS source mapping.

Application modes

Web, PWA, mobile, desktop, and SSR descriptors with shipping native hosts: Android WebView, iOS WKWebView (Xcode project), and Electron desktop shell.

Templates

External HTML by default

Generated Java classes point to files like HomePage.html, so designers and Java developers can work against clear file boundaries.

Routing

History, hash, and anchor

Switch modes with javelle mode routing web history --fallback, hash, or anchor. Generated apps publish anchor-routing discovery files.

Native

Java APIs over platform plugins

javelle plugin add gps writes a plugin manifest while Java facades such as Gps, Device, and Clipboard call a typed WebView-to-native bridge.

MVC

SpringFabric as an MVC option

javelle mvc demo --spring-fabric installs an intent-first AXIS handler demo where MVC renders the page and browser calls dispatch through a typed SpringFabric envelope.

Styles

CSS plus SCSS source

Created apps include /styles/app.css and styles/app.scss, declared in javelle.config.json for a future Sass build pipeline.

Testing

One-shot test & doctor

javelle test runs Maven, JVL linting, jsdom runtime tests, and an optional smoke build. javelle doctor validates JDK, Node, Maven, Android SDK, Xcode, and project config before you ship.

Target modes

One project layout, multiple delivery targets.

Modes are explicit descriptors under src/main/javelle/modes. The CLI creates target-specific support files without overwriting existing work.

web Static web resources, runtime script, history or hash routing, and dev-server fallback.
pwa Web app manifest and service-worker assets for installable browser experiences.
mobile Combined mobile target preparing both Android and iOS WebView shells with a typed native bridge and plugin selection.
android Android WebView host with the Javelle native bridge, generated host config, and APK or app-bundle output.
ios iOS WKWebView host with the Javelle native bridge, generated Xcode project, and app host config.
desktop Electron-based desktop host with main / preload templates, window metadata, and bridge classes for Windows, Ubuntu, and macOS.
ssr Server-side rendering descriptor, rendering config, and generated SSR entry point.

Native plugin catalog

Only include the plugins your app actually uses.

Javelle generates Android permission manifests and iOS Info.plist entries directly from your enabled plugins. Enable a plugin and the right permissions appear. Disable it and they are removed. No manual manifest editing required.

Camera

Photo and video capture via the device camera API with preview and crop support.

javelle plugin add camera

GPS

Device location with high-accuracy, balanced, and passive power modes.

javelle plugin add gps

Clipboard

Read and write text to the system clipboard using secure platform APIs.

javelle plugin add clipboard

Device

Device info: model, OS version, screen size, orientation, and battery level.

javelle plugin add device

Network

Monitor connectivity state, network type, and connection quality changes.

javelle plugin add network

Secure Storage

Small encrypted key-value storage in the app sandbox.

javelle plugin add secure-storage

Local Notifications

Schedule local reminders and app notifications with channels and actions.

javelle plugin add local-notifications

Biometrics

Fingerprint and face authentication through the system biometric API.

javelle plugin add biometrics

NFC

Read and write NFC tags and peer-to-peer data exchange on supported devices.

javelle plugin add nfc

Media Capture

Capture photos, video, and audio from device inputs. Pair with the media plugin for playback.

javelle plugin add media-capture

File System

Read, write, and manage files in sandboxed device storage with typed paths.

javelle plugin add filesystem

SMS

Send text messages via the device messaging API. Only include when required.

javelle plugin add sms

Javelle Lightweight Standard v1

Ship only what is needed.

A strict set of defaults to keep Javelle apps fast, small, and secure across every delivery target — web, PWA, mobile, and desktop. These are the recommended rules, not optional suggestions.

Images

WebP by default

  • WebP as the primary image format
  • SVG for icons and simple illustrations
  • PNG only when truly necessary
  • Resize before bundling, thumbnails where possible
  • Do not ship desktop-sized images to mobile targets

Fonts

Noto Sans, bundled locally

  • Default: Noto Sans — broad language and Arabic coverage
  • Arabic: Noto Sans Arabic
  • Mono: Noto Sans Mono (optional)
  • Maximum 2–3 weights: 400, 500, 700
  • Bundle locally — no remote font calls in production

Icons

SVG, minimal set

  • SVG icons inline or as a small local sprite
  • No large icon libraries when only a few icons are used
  • Optimise SVGs before bundling

Plugins

Per-plugin, permission-aware

  • Only include native plugins that are actually used
  • Permissions auto-generated from enabled plugins only
  • Request runtime permissions only when needed
  • Never add all permissions by default

Security

HTTPS first

  • usesCleartextTraffic=false by default on Android
  • HTTPS enforced across all delivery targets
  • Bundle core UI assets locally when possible
  • Avoid remote CDN dependencies for critical UI

Build

Shrink everything

  • Code shrinking and resource shrinking enabled
  • Minify CSS and JS for release builds
  • Tree-shake unused code paths
  • Remove debug code in release output
  • Keep startup payload small across all targets
Implemented

What exists today

The current repository focuses on the project system, Java runtime surface, and developer workflow.

  • Maven multi-module project with core, CLI, UI, runtime, and testing modules.
  • Generators for pages, components, stores, services, boot files, layouts, and modules.
  • Template renderer, router, forms, i18n, stores, plugins, MVC layer, and test harness.
  • Dev server with config and router endpoints, 404 page, and history fallback support.
  • DevTools protocol, reactive instrumentation, redacted debug report export, and bundled Javelle Studio.
  • VS Code commands to open Studio, inspect the current component, show the dependency graph, and export reports.
  • Native plugin bridge contracts, a plugin catalog, permission manifest output, and javelle plugin commands.
  • SpringFabric-style AXIS contracts, handler dispatch, guards, interceptors, and an MVC demo option.
Next

What comes next

The next stage turns the foundation into a fuller browser and packaging workflow.

  • Java-to-browser compilation through J2CL or a similar pipeline for full client-side reactivity.
  • Production packaging installers for Windows, macOS, Ubuntu Touch, and notarised iOS/macOS distribution.
  • Deeper Studio panels for build-size analysis, device matrices, network/API inspection, and storage inspection.
  • Community plugin registry and a third-party component / preset marketplace.

Runtime contract

Try the Javelle HTML runtime attributes.

Real <input>, <select>, and <textarea> elements wired to the Javelle runtime contract via data-jv-action — no build step, no framework required.

data-jv-action="notify-form"

Reads name="level", name="message", and name="position" from the closest <form> and fires a toast notification. HTML5 validation runs first.

data-jv-action="dark-toggle"

Toggles .body--dark on <body> and .j-dark on <html>. Dark theme styles are scoped under those ancestor selectors.

data-jv-drawer-toggle="#main-drawer"

Opens or closes the off-canvas .j-drawer element by toggling .j-drawer--open and syncing aria-hidden.

data-jv-action="copy"

Copies the value of data-jv-copy to the clipboard. Used on every "Copy" button in the Quick Start section above.

Build with it

Start from the demo, then turn the generated app into your product shell.

The fastest path is to run the demo script, inspect the generated project, then use the CLI to add pages, modules, routing mode, UI assets, fonts, icons, SCSS-backed app styles, and Studio visibility.

Use the quick start Review architecture Open Studio guide