# jgo
**Repository Path**: mirrors_scijava/jgo
## Basic Information
- **Project Name**: jgo
- **Description**: Launch Java code from the CLI, installation-free. ☕
- **Primary Language**: Unknown
- **License**: Unlicense
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-09-25
- **Last Updated**: 2026-01-04
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
[](https://github.com/apposed/jgo/actions/workflows/build.yml)
# jgo: painless Java component execution
## Summary
`jgo` launches Java applications directly from Maven coordinates—no installation required. Just specify a Maven artifact identifier and an optional main class, and `jgo` resolves dependencies, materializes the environment including the version of Java needed, and runs your program.
```bash
# Run Jython REPL (latest version)
jgo org.python:jython-standalone
# Run with specific version
jgo org.python:jython-standalone:2.7.3
```
### What's New in 2.0
- **🎯 Zero-configuration execution**: Automatic Java download and version management thanks to `cjdk` integration
- **📦 Reproducible environments**: `jgo.toml` project files with lock files (like `package.json` + `package-lock.json`)
- **🏗️ Three-layer architecture**: Independently useful layers for Maven resolution, environment building, and execution
- **🐍 Pure Python resolver**: No Maven installation required for basic operations
- **🔧 Powerful Python API**: Fine-grained control over dependency resolution and execution
See [docs/migration.md](docs/migration.md) for migration from jgo 1.x.
## Quick Start
### CLI Usage
```bash
# Run Jython REPL
jgo org.python:jython-standalone
# Run with arguments
jgo org.python:jython-standalone -- -- script.py --verbose
# Multiple artifacts with main class (use @ separator)
jgo org.scijava:scijava-common+org.scijava:scripting-jython@ScriptREPL
# Force update from remote repos
jgo -u org.python:jython-standalone
# Use specific Java version
jgo --java-version 17 net.imagej:imagej
# Print classpath without running
jgo info classpath org.python:jython-standalone
# Preview commands without executing (--dry-run)
jgo --dry-run run org.scijava:parsington # See java command
jgo --dry-run init org.python:jython-standalone # Preview jgo.toml
```
### Python API
```python
import jgo
# Simple one-liner
jgo.run("org.python:jython-standalone:2.7.3", app_args=["script.py"])
# Build environment without running
env = jgo.build("org.python:jython-standalone")
print(env.classpath) # List of JAR paths
# Resolve dependencies
components = jgo.resolve("org.python:jython-standalone")
for comp in components:
print(f"{comp.groupId}:{comp.artifactId}:{comp.version}")
```
### Project Mode with jgo.toml
Create reproducible environments:
```toml
# jgo.toml
[environment]
name = "my-java-app"
[dependencies]
coordinates = ["net.imagej:imagej:2.15.0"]
[entrypoints]
default = "net.imagej.Main"
[settings]
cache_dir = ".jgo" # Local environment like .venv
```
```bash
# Run from current directory
jgo
# Creates .jgo/ with jars/ and jgo.lock.toml
# Add to git: jgo.toml, jgo.lock.toml
# Ignore: .jgo/
```
## Installation
The `jgo` project began life as a shell script, but was later translated into
Python, so that tools such as [scyjava](https://github.com/scijava/scyjava)
could leverage its environment-building capabilities.
Installing jgo with uv
```shell
uv tool install jgo
```
Installing jgo with pip
```shell
pip install jgo
```
Installing jgo with conda
```shell
conda install -c conda-forge jgo
```
Installing jgo from source
```shell
git clone https://github.com/apposed/jgo
uv tool install --with-editable jgo jgo
```
When installed in this fashion, changes to the jgo source code will be immediately reflected when running `jgo` from the command line.
Using jgo as a dependency
```shell
uv add jgo
```
or
```shell
pixi add jgo
```
Not sure which to use? [Read this](https://jacobtomlinson.dev/posts/2025/python-package-managers-uv-vs-pixi/#so-what-do-i-use).