01What webforJ is

A screen is a Java class.

webforJ is the full-stack Java framework for business web apps: you build the whole app, screens included, in Java.

A route makes it a page. Put @Route on a class and it answers at that address in the browser.
Components are fields. Create them with new, react to clicks with a lambda.
Java or Kotlin. The Kotlin DSL builds the same screen with the same components.

Components built for business apps.

Fields, lists, dialogs, uploads, charts, trees and layouts come with webforJ. Each one is a Java class you create in your screen.

Theming starts from a seed. Set the primary seed and all 19 shades of the palette follow, in every component.

app.css

:root {
  --dwc-color-primary-seed: #6366f1;
}

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

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

Inspect components. Browse the component tree, select a component by clicking it in the page, and change its properties while the app runs.
Write changes to source. Review your live edits as a diff and apply them to the Java file they came from.
The AI assistant. A coding agent inside the running app writes Java, compiles what it wrote, and applies it with your approval.

Forms, rules and access, next to your backend.

Binding. BindingContext pairs the form fields with a bean and checks its Jakarta validation rules when you write the form back.
Spring Boot. Views take your services, repositories and other Spring beans through constructor injection.
Security. Annotations such as @RolesAllowed guard a route, and the rules are enforced before any component is rendered.

Read more: Showcase

CustomerFormView.java

public class CustomerFormView extends Composite<FlexLayout> {
  private TextField name = new TextField("Name");
  private TextField email = new TextField("Email");
  private Customer customer = new Customer();

  private BindingContext<Customer> context =
      BindingContext.of(this, Customer.class, true);

  public CustomerFormView() {
    Button save = new Button("Save", ButtonTheme.PRIMARY, e -> {
      ValidationResult result = context.write(customer);
      if (result.isValid()) {
        Toast.show("Saved " + customer.getEmail(), Theme.SUCCESS);
      }
    });

    getBoundComponent().add(name, email, save);
  }
}

public class Customer {

  @NotEmpty(message = "Name cannot be empty")
  private String name;

  @NotEmpty(message = "Email is required")
  @Email(message = "Not a valid email address")
  private String email;

  // getters and setters
}

@Route("/dashboard")
public class DashboardView extends Composite<FlexLayout> {

  public DashboardView(RandomNumberService service) {
    Button roll = new Button("Generate random number");
    roll.setTheme(ButtonTheme.PRIMARY)
        .addClickListener(e ->
            Toast.show("The new random number is "
                + service.nextNumber(), Theme.SUCCESS));

    getBoundComponent().add(roll);
  }
}

05Your existing code comes along

Bring the code you already have.

WebswingConnector puts a running Swing, JavaFX or SWT app inside a webforJ view, so a rewrite never has to happen all at once.

ElementComposite wraps a custom HTML element or web component in a Java class, with its properties, attributes and events in Java.

Your AI assistant follows webforJ conventions.

One install of the webforJ AI plugin gives your coding assistant the webforJ MCP server and Agent Skills.

The server gives it live tools. The skills tell it when to use them, in what order, and how to check the result.

That was the whole stack. You are ready to build.

Consider yourself unofficially certified: you have seen how a webforJ app is put together, from the first screen to the AI tooling that helps you write the next one.

What webforJ is
Components and theming
craftforJ
Data, forms and security
Your existing code
AI tooling and next stops