mrkeyoor.com_
Tue 01 Sept 17:45 UTC
Automationevaluationupdated 26 Aug 2026

generator-jhipster review

JHipster generates full web applications and microservice systems around Java and Spring Boot, with Angular, React, or Vue on the client. It solves the blank-project problem by producing an opinionated application, build setup, security choices, database integration, and deployment files from one configuration.

+0stars / 7d
Verdict

Our JHipster run built in 44 seconds and passed 10,348 tests, but 888 failures still made the 141-second test command exit 255. That result makes the current checkout a poor candidate for blind adoption, even though the 0-vulnerability audit and active release work are encouraging. Use JHipster when a Java team wants its specific full-stack conventions across several applications and has budget to review generated changes; choose a smaller generator for one ordinary Spring service.

We ran it

Lab card: what happened when we ran generator-jhipsterScreenshot of generator-jhipster (www.jhipster.tech)
Install✓ · 61s711 packages · 239 MB
Build✓ · 44s
Tests✗ · 141s10348 passed · 888 failed of 11236 (mocha)
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo3981 files~136,611 lines of source · 18.4 MB · 24 CI workflows · Dockerfile · tests dir

Answers from our run

Does generator-jhipster build from source?

Dependencies installed in 61 seconds (711 packages), and the build succeeded in 44 seconds. We cloned commit 88a26c9 into a clean Debian container with 3 CPUs and no project-specific setup.

Do generator-jhipster's tests pass?

Not all of them: 10348 of 11236 passed and 888 failed when we ran the project's own test command (mocha). Some failures need services or credentials a bare container does not have.

Does generator-jhipster have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use generator-jhipster?

Small backend services that only need a Spring Boot skeleton: JHipster brings a full generator and front-end choices where Spring Initializr may be enough.

What are the alternatives to generator-jhipster?

Spring Initializr, Cookiecutter, Nx. Our JHipster run built in 44 seconds and passed 10,348 tests, but 888 failures still made the 141-second test command exit 255.

Setup2/5Build passed, but 888 of 11,236 tests failed in our run
Docs4/5Large website and matrices; the repository README is only a gateway
Community5/522,446 stars with active issues and PRs on August 26, 2026
Maturity4/5v9.2.0 spans mature stacks, but the current suite failed here

Who it’s for

Java teams that want Spring Boot and a supported Angular, React, or Vue client generated together.
Organizations starting several services that benefit from one repeatable application shape and JDL models.
Teams willing to keep generated code, templates, and framework upgrades under normal source control review.
Developers who can run the verified Java 21 or 25 and Node 22 or 24 combinations.

Who it’s NOT for

Small backend services that only need a Spring Boot skeleton: JHipster brings a full generator and front-end choices where Spring Initializr may be enough.
Teams outside the Java and Spring Boot stack: the project is built around that backend rather than offering language-neutral generation.
Developers expecting the current checkout to have a clean test command in every fresh Node 22 environment: our run ended with 888 Mocha failures despite 10,348 passing tests.
Organizations unwilling to own generated framework code after creation: v9.2.0 changed Spring Boot, Gradle, Node, webpack-dev-server, front-end tests, and more than 3,000 EJS templates, so upgrades can span the whole application.

Setup reality

Our sandbox installed 711 npm packages in 61 seconds and used 239 MB. The build passed in 44 seconds. Tests failed with exit 255 after 141 seconds: Mocha reported 10,348 passed, 888 failed, and 47 pending out of 11,236. Npm audit found 0 known vulnerabilities.

The current README lists Java 21 or 25 with Node 22 or 24 as CI-verified combinations. Generating and running an application adds the selected database, Java build tool, front-end framework, authentication system, and deployment target.

The generator checkout is only one layer. A generated app may need Docker, registry credentials, Maven or Gradle downloads, and service-specific configuration. Our run tested the generator repository, not a generated monolith or microservice system.

JHipster generates an application stack, not a starter folder

JHipster takes choices about architecture, database, authentication, build system, and client framework, then writes a working Java application around them. Spring Boot is the backend foundation; Angular, React, and Vue are the supported client families. It can target a monolith or a microservice architecture, with JDL available to describe applications and entities. The appeal is consistency: a team can create several services without rebuilding security, entity screens, test wiring, and deployment files by hand.

That output is far broader than a dependency picker. Release v9.2.0 mentions more than 3,000 EJS templates, Spring Boot 4.0.7, Gradle 9.6.1, Node 24.18.0, and webpack-dev-server 6. A generated project therefore contains decisions from several fast-moving ecosystems. JHipster can save the first weeks of assembly, but the generated repository becomes your application. Its upgrades deserve the same review as a large framework migration.

Java 21 or 25 and Node 22 or 24 narrow the supported path

The repository README now gives a small, useful compatibility table. GitHub Actions verifies Java 21 and 25 against Node 22 and 24. Using those combinations removes one class of uncertainty when contributing to the generator. The published package installs globally with npm, while the documentation also describes a Docker route for people who want the toolchain contained.

Application setup grows with the selected blueprint. Maven or Gradle has to fetch the Java side, npm installs the generated client, and databases or identity providers must exist before realistic use. Docker deployment may need registry credentials. A microservice selection adds service discovery, gateways, and multiple deployable units. None of that is a defect in the generator. It means the short global install command measures access to JHipster, not the effort required to operate what it creates.

What happened when we ran it

Our clean Node 22 sandbox installed 711 npm packages in 61 seconds. The resulting dependency directory used 239 MB, and npm audit reported 0 known vulnerabilities across critical, high, moderate, and low severities. The build succeeded in 44 seconds. Those are respectable numbers for a generator spanning thousands of source files and several application families.

The test command was different. It ran for 141 seconds and exited 255. Mocha reported 10,348 passing, 888 failing, and 47 pending out of 11,236 tests. The final log lines listed contexts such as invalid Java field names, invalid Angular field names, missing files, existing application configuration, and unidirectional relationship options. The supplied tail did not include failure messages or stack traces, so it supports no claim about the cause.

A high passing count cannot turn that command green. The useful conclusion is that commit 88a26c9 installed and built in our fresh unprivileged container, while its complete measured test step did not pass there. The checkout contained 3,981 files, about 136,611 lines of source, and 18.4 MB before installation. It also had 24 CI workflow files, a Dockerfile, and a tests directory, which matches the project's unusually wide compatibility surface.

A generated codebase trades early speed for long ownership

JHipster is most persuasive when an organization has already chosen its stack. A Java shop standardizing on Spring Boot, one of 3 client frameworks, and a known database can encode those choices once. Entity generation and JDL then reduce repeated work. Daily build matrices cover Angular, React, Vue, Maven, Gradle, SQL, NoSQL, OAuth 2.0, JWT, Docker, and Windows combinations.

The same matrix explains why upgrades can be involved. Version 9.2.0 completed a move to Vitest for generated front ends, removed Jest from client choices, tightened generated backend security, and repaired framework-specific entity behavior. An existing generated application does not magically receive every correction. Teams need the documented upgrade process, meaningful diffs, and regression tests around their custom code.

Generated code also changes the debugging question. When something breaks, engineers must decide whether the problem comes from local edits, a chosen blueprint, a template, or an upstream framework. That is manageable when several teams share JHipster knowledge. It is a costly tax when one developer generated an application once and nobody understands the conventions six months later.

The August 26 activity shows a maintained but moving target

GitHub listed 22,446 stars and 92 combined issues and pull requests, with the last push on August 26, 2026. Current work included React's move to Vite and Angular microfrontend changes. Release v9.2.0 was published on July 10, 2026, so the repository had both a recent stable tag and post-release development. The combined open count should not be read as 92 bugs.

The project is mature enough to have explicit support combinations, extensive CI, daily generated-application builds, and a detailed release process. Our 888 failing tests still matter because they show that a fresh supported Node image did not reproduce a clean suite for the measured commit. Before standardizing, generate the exact application shape your teams want, build it on the target Java version, and test an upgrade.

JHipster earns its cost when the conventions repeat

A single conventional Spring API rarely needs this much machinery. Spring Initializr gets that team to a smaller starting point, while a custom Cookiecutter template fits organizations with established conventions outside JHipster's menu. JHipster becomes easier to justify when multiple applications share authentication, entity patterns, front-end structure, and deployment assumptions.

Our run found a fast build, a clean dependency audit, and a large failing suite in the same checkout. That mixed result fits the product: there is serious engineering here, but also a very wide surface to verify. Adopt it as an organizational platform with owners and upgrade practice. Do not treat the generator as a one-time shortcut whose output will maintain itself.

Alternatives

ProjectWhat it isPick it when
Spring InitializrA focused Spring project generator that selects dependencies without creating a full client application.pick this instead when you want a clean Spring Boot starting point and prefer to choose the front end and architecture yourself.
CookiecutterA language-neutral project templating tool driven by reusable templates and prompts.pick this instead when your organization has its own project shape or does not use Java.
Nx gh↗A monorepo build system and generator platform centered on JavaScript and TypeScript projects.pick this instead when the workspace is primarily TypeScript and monorepo task orchestration matters more than a Spring stack.

What people are saying

  1. [velocity-scout] jhipster/generator-jhipster

Sources

  1. JHipster generator README
  2. JHipster documentation
  3. JHipster v9.2.0 release

More automation reviews

rclone · lego · OpenCLI · web-access · Karabiner-Elements · WiiUDownloader · the whole board →