[package]

name = "jav"

version = "2026.623.8"

version = "2026.624.1"

edition = "2021"

description = "A modern CLI for Java projects"

license = "MIT"

Generated runnable projects include a `jav.toml` file for run defaults such as main class and Maven/Gradle task. Edit it when a project needs a custom run shape.

Projects also generate a `flake.nix` by default for a pinned Java/build-tool environment. Use `--no-flake` if you do not want Nix files.

## Templates

Installed templates:

Template aliases are supported too, for example `webapi` for `springweb` and `classlib` for `library`.

Generated dependency versions are pinned in Maven/Gradle files. For fully reproducible project builds, commit `flake.lock` and enable Maven/Gradle dependency locking as needed for the project.

## Install

Run without installing through Nix:

/// Build tool to generate: maven or gradle. Defaults depend on the template.

#[arg(long)]

pub build_tool: Option<String>,

/// Do not generate a Nix flake for the project.

#[arg(long)]

pub no_flake: bool,

/// Java language version.

#[arg(long, default_value = "21")]

pub java_version: String,

spring_boot_version: args.spring_boot_version,

spring_features,

main_class,

include_flake: !args.no_flake,

};

render::render(&template_manifest.id, &destination, context).with_context(|| {

pub spring_boot_version: String,

pub spring_features: Vec<String>,

pub main_class: String,

pub include_flake: bool,

}

pub const TEMPLATE_IDS: &[&str] = &[

manifest: &TemplateManifest,

context: &TemplateContext,

) -> Option<Vec<(&'static str, &'static str)>> {

match manifest.renderer.as_str() {

let mut files = match manifest.renderer.as_str() {

"plain-app" => Some(match context.build_tool.as_str() {

"gradle" => vec![

(".gitignore", include_str!("../../templates/common/gitignore")),

Some(files)

}

_ => None,

}?;

if context.include_flake {

files.push((

"flake.nix",

include_str!("../../templates/common/flake.nix"),

));

}

Some(files)

}

fn plain_main_file(template: &str) -> &'static str {

tera_context.insert("package_path", &context.package_path);

tera_context.insert("java_version", &context.java_version);

tera_context.insert("build_tool", &context.build_tool);

tera_context.insert("is_maven", &(context.build_tool == "maven"));

tera_context.insert("is_gradle", &(context.build_tool == "gradle"));

tera_context.insert(

"is_spring",

&context.spring_features.iter().any(|feature| {

matches!(

feature.as_str(),

"web" | "actuator" | "data-jpa" | "security" | "postgresql" | "batch"

)

}),

);

tera_context.insert("spring_boot_version", &context.spring_boot_version);

tera_context.insert("main_class", &context.main_class);

tera_context.insert(

jav run

```

With Nix:

```bash

nix develop

nix run .#build

nix run .#test

nix run .#run

```

Commit `flake.lock` after the first Nix command if you want the development environment pinned exactly.

Build tool: `{{ build_tool }}`

Java version: `{{ java_version }}`

{

description = "{{ project_name }}";

inputs = {

nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

};

outputs = { self, nixpkgs, ... }:

let

systems = [

"x86_64-linux"

"aarch64-linux"

"x86_64-darwin"

"aarch64-darwin"

];

forAllSystems = nixpkgs.lib.genAttrs systems;

projectFor = system:

let

pkgs = import nixpkgs { inherit system; };

buildTool = {% if is_maven %}pkgs.maven{% else %}pkgs.gradle{% endif %};

in

{

devShells.default = pkgs.mkShell {

packages = [

buildTool

pkgs.jdk{{ java_version }}

];

JAVA_HOME = pkgs.jdk{{ java_version }};

};

apps = {

build = {

type = "app";

program = "${pkgs.writeShellScript "{{ project_name }}-build" ''

{% if is_maven %}exec ${buildTool}/bin/mvn package "$@"{% else %}exec ${buildTool}/bin/gradle build "$@"{% endif %}

''}";

};

test = {

type = "app";

program = "${pkgs.writeShellScript "{{ project_name }}-test" ''

{% if is_maven %}exec ${buildTool}/bin/mvn test "$@"{% else %}exec ${buildTool}/bin/gradle test "$@"{% endif %}

''}";

};

run = {

type = "app";

program = "${pkgs.writeShellScript "{{ project_name }}-run" ''

{% if is_maven and is_spring %}exec ${buildTool}/bin/mvn spring-boot:run "$@"{% elif is_maven %}exec ${buildTool}/bin/mvn compile exec:java "$@"{% elif is_spring %}exec ${buildTool}/bin/gradle bootRun "$@"{% else %}exec ${buildTool}/bin/gradle run "$@"{% endif %}

''}";

};

default = self.apps.${system}.run;

};

};

in

{

devShells = forAllSystems (system: (projectFor system).devShells);

apps = forAllSystems (system: (projectFor system).apps);

};

}

project

.child(".gitignore")

.assert(predicate::path::exists());

project.child("flake.nix").assert(predicate::path::exists());

project.child("jav.toml").assert(predicate::path::exists());

project

.child("src/main/java/dev/example/demo/Main.java")

.assert(predicate::path::exists());

}

#[test]

fn new_can_skip_flake_generation() {

let temp = assert_fs::TempDir::new().unwrap();

let project = temp.child("NoFlake");

let mut command = Command::cargo_bin("jav").unwrap();

command

.current_dir(temp.path())

.args([

"new",

"console",

"--name",

"NoFlake",

"--package",

"dev.example.noflake",

"--no-flake",

])

.assert()

.success();

project

.child("flake.nix")

.assert(predicate::path::missing());

project.child("pom.xml").assert(predicate::path::exists());

}

#[test]

fn new_without_template_prints_catalog() {

let mut command = Command::cargo_bin("jav").unwrap();