The visual editor for webforJ

See the app your Java built. Change it while it runs.

craftforJ runs inside your app in development mode. It shows the component tree your code created, lets you change properties live, and writes the changes you keep back into the Java file that created them.

Get started Read the docs

Four shortcuts cover the loop

Open or closeAltShiftD
Pick a componentAltShiftC
Review changesCmd/CtrlS
Undo a changeCmd/CtrlZ

How it works

It reads your app through webforJ itself

That is why it describes the app in the terms you wrote it in. The tree lists your components, the properties are the ones your components declare, and the routes are the ones your router registered, with the access rules you annotated them with.

01
Open
Click the trigger button over your app, or press Alt+Shift+D from anywhere in it.
02
Pick
Press Alt+Shift+C, hover a component and click it. The tree selects it and the sidebar fills with its properties.
03
Change
Edit a property. The running app updates immediately, and your files stay untouched.
04
Keep
Review the change as a diff and apply it to the Java file that created it.

A tour of the panels

The panels, over a real app

Video

1 of 2

The component tree your Java built

The Inspector lists your components, not the markup the browser rendered. A Composite appears as the class you wrote, holding its children in the order webforJ holds them.

Inspecting components docs

Press Alt+Shift+C and click anything in the page to select it in the tree.
Change a property in the sidebar and the running app updates immediately.
Trace a component back to the Java line that created it.

VideoSave to source

Review the diff, then write it to Java

Every property you change is recorded as a pending change. Press Cmd/Ctrl+S to review them grouped by the file they land in, each with its old and new value and the diff of the file. Nothing is written until you apply.

Applying changes docs

Pending changes survive a page reload and a route change.
Write a change at the usage, for one screen, or at the definition, for every screen that uses it.
Cmd/Ctrl+Z undoes a change, including one already written to your files.

Video

1 of 2

The routing table, live

The Routes tab shows the routing table in the hierarchy the router holds it in, with the active route marked. Routes registered dynamically appear alongside annotated ones.

Routes docs

Navigate to any route from craftforJ. Your lifecycle observers run as they would for a user.
Each route carries a badge for the security annotation declared on it.
Change an access rule and craftforJ writes the annotation into the route class.

VideoTheme controls

Retheme the app while it runs

The Theme tab works with the DWC design tokens your app already uses, so one change reaches every component that reads that token. Controls cover the palette, surfaces, edges and corners, typography and spacing.

Theme docs

Edit the light side, the dark side or both, and flip the app between them.
Start from a preset such as App Default or Portico.
Saving writes the theme into your stylesheet, where it ships with your app.

VideoA conversation

An agent that compiles before you see it

The assistant is a coding agent inside your running app. It writes Java, sends each staged edit to a real Java compiler and fixes its own mistakes from the diagnostics, so what reaches your review already compiles.

AI assistant docs

Choose how much it does alone: ask before acting, apply edits automatically, or run autonomously.
Use an API key for a supported provider, or a model running locally.
It talks to your provider from the browser, with no relay and no proxy.

ScreenshotApp info

The App Info panel listing the webforJ version, project root, Java runtime and operating system

What your app is really running with

App info reports the versions the app runs with, which is not always what your pom.xml says. It covers webforJ and BBj Services, the Java runtime, the operating system and the project root.

App info docs

The project root is where craftforJ looks for your sources.
The Java runtime decides how thoroughly assistant edits are validated. Full validation needs a JDK.

Back to source

It edits the Java, not a copy of it

Take a form with a Save and a Cancel button. Select Save, right-click it in the tree and choose Remove from source. The declaration, the theme, the listener, its place in the add() call and the ButtonTheme import nothing else uses are gone. Cancel stays.

Before

ContactFormView.java
import com.webforj.component.button.Button;
import com.webforj.component.button.ButtonTheme;
import com.webforj.component.layout.flexlayout.FlexLayout;

public class ContactFormView {
  public ContactFormView(FlexLayout layout) {
    layout.setSpacing("1em");
    Button save = new Button("Save");
    save.setTheme(ButtonTheme.PRIMARY);
    save.onClick(event -> {
      save.setEnabled(false);
    });
    Button cancel = new Button("Cancel");
    layout.add(save, cancel);
  }
}

After Remove from source

ContactFormView.java
import com.webforj.component.button.Button;
import com.webforj.component.layout.flexlayout.FlexLayout;

public class ContactFormView {
  public ContactFormView(FlexLayout layout) {
    layout.setSpacing("1em");
    Button cancel = new Button("Cancel");
    layout.add(cancel);
  }
}

Two settings, both required
craftforJ needs webforj.debug and webforj.devtools.craftforj.enabled. Neither does anything on its own.
Local access by default
Only a browser on the machine running the app can reach it, until you name another machine in hosts-allowed.
No added HTTP surface
It adds no endpoint, servlet or filter. It works over the connection your app already has.
Writes only what compiles
A removal from source is only written if the result still compiles, and files are never deleted.

Getting started

Turn it on in three steps

craftforJ ships with webforJ, so there is nothing to download separately. Projects created with startforJ or from a webforJ archetype come with it enabled. Run the app and go straight to step three.

Add the dependency

Add webforj-devtools to your project if it is not there already.

pom.xml
<dependency>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-devtools</artifactId>
  <version>${webforj.version}</version>
</dependency>

2
Enable debug mode and craftforJ
Set both properties in webforj.conf, or in application.properties for a Spring project. craftforJ only works when both are enabled.
```
webforj.debug = true
webforj.devtools.craftforj.enabled = true
```
3
Restart, reload and open it
Open the app from the machine that runs it. A trigger button appears over your app. Click it, or press AltShiftD from anywhere in the app. The same shortcut closes craftforJ again.
craftforJ floats over your app by default. Drag it onto an edge to dock it there, or move it into a browser window or tab of its own for a second monitor.

Where next

Every panel has its own page in the docs

webforJ is the full-stack Java framework for business web apps: you build the whole app, screens included, in Java. craftforJ ships with it and works on the app you are running.

The craftforJ assistant Back to the docs home

It reads your app through webforJ itself

Open

Pick

Change

Keep

The panels, over a real app

The component tree your Java built

It edits the Java, not a copy of it

Two settings, both required

Local access by default

No added HTTP surface

Writes only what compiles

Turn it on in three steps

Add the dependency

Enable debug mode and craftforJ

Restart, reload and open it

Every panel has its own page in the docs