JBang

JBang IntelliJ Plugin — Rewritten from Scratch

2026-08-22T00:00Z[Etc/UTC]

The JBang IntelliJ plugin has been completely rewritten. Version 0.100.0 is not an incremental update — it is a ground-up rewrite that makes JBang scripts proper first-class citizens inside IntelliJ IDEA.

What changed and why

The old plugin (≤ 0.26) worked by mutating IntelliJ modules to try and get intellij to fit to JBang. That approach was fragile — it used old API that Jetbrains marketplace kept blocking the release for. It also conflicted with Gradle and Maven projects, and could not handle multiple scripts with different classpaths in the same directory.

The new plugin takes a fundamentally different approach: it uses jbang info tools as its single source of truth like how the VSCode plugin does but goes a step further and overlays dependencies as synthetic libraries.

Hence making IntelliJ aware of JBang scripts without ever mutating the project model. This means that you can have a Gradle or Maven project and still use JBang scripts in the same folder without any conflicts.

Total freedom!

Per-script classpath isolation

Each JBang root script now keeps its own isolated classpath, declared sources, and requested Java version.

If you have three scripts in the same directory with different //DEPS, each one resolves independently.

You can even have multiple roots that reuses the same source files. When multiple roots you can switch between which is used for classpath resolving.

Total freedom!

Dependencies show up under External Libraries as clearly labeled JBang entries — you can navigate from a library JAR back to the root script that owns it (press kbd:Enter)

Other big enhancements include that Run and Debug are now fully supported, with JDWP auto-attach for debugging. Run JBang also now use IntelliJ’s terminal so you can write and debug TUI applications without leaving the IDE. Finally!

What got fixed

This rewrite addressed a long list of issues and feature requests that had accumulated over the years:

#153 — Poor experience with multiple scripts in one directory → multi-root isolation
#112 — Sync dependencies between JBang and IDEA .iml file → overlay-based, no .iml mutation
#111 — Debug button disabled → full Run + Debug support with JDWP auto-attach
#136 — Cannot add environment variables to run config → expanded run configuration
#128 — Support Kotlin → Kotlin, Groovy, JShell, and .jbang all supported
#139 — JDK version overwritten when //JAVA is omitted → standalone SDK handling fixed
#135 — Code completion proposes wrong version numbers → rewritten Maven coordinate completion with local/remote/snapshot distinction
#147 — Failed to resolve DEPS with global JVM options → CLI invocation rewritten
#143, #134, #96 — Various IntelliJ compatibility exceptions → clean platform API usage
#151 — Blurry icon → all icons replaced with SVGs
#124 — WSL support → now supported
#102 — Improve the JBang experience in IntelliJ → well, that was the whole point
#160 — Run config breaks on file rename/move → fixed
#161 — Non-JBang files checked for JBang errors → fixed, directives only matched at column 0

New capabilities

Beyond fixing what was broken, the rewrite adds things that were never possible before:

//SOURCES and //FILES navigation — Ctrl/Cmd-click jumps to declared sources and resources, with path completion as you type.
Catalog support — JSON Schema for jbang-catalog.json, plus script-ref completion and navigation.
Exact diagnostics — unknown directives, malformed coordinates, duplicate //DEPS, unresolved dependencies, and missing resources highlighted on the exact failing token.

Terminal execution — run scripts in IntelliJ’s terminal with Windows PTY fallback.
CLI-backed templates — New → JBang Script loads templates directly from jbang template list.
Contextual feature tips — the plugin walks you through its capabilities as you use them.

What got removed

The rewrite also deleted code that was never working well or pulling its weight:

Module builder/wizard — just open a folder.
Gradle dependency mirroring — the config file was empty, it never actually worked.
DependencyModifier — always returned false.
Custom tool window with dependency list — replaced by status bar widget and External Libraries.
Live templates — replaced by CLI-backed templates that stay in sync with JBang itself.

Try it

The plugin has been submitted to the JetBrains Marketplace but approval can take a few days. You don’t have to wait — there are two ways to get it now:

Option 1: Add the EAP update channel (recommended)

This gives you automatic updates for every new build, including pre-release fixes:

In IntelliJ: Settings → Plugins → ⚙ → Manage Plugin Repositories…
Add: https://plugins.jetbrains.com/plugins/eap/18257
Click OK, then search for "JBang" in the Marketplace tab and install or update.

The EAP channel receives every successful build from main, so you always get the latest.

Option 2: Install from disk

Download jbang-idea-plugin-0.100.0.zip from the GitHub release.
In IntelliJ: Settings → Plugins → ⚙ → Install Plugin from Disk… → select the zip.
Restart.

Once JetBrains approves the update it will show up in the stable Marketplace channel as usual.

Please try it and experiment with proper IDE integration for your JBang scripts — and let us know how it works! Feedback, bug reports, and feature requests are welcome at github.com/jbangdev/jbang-idea/issues.

Somehow, JBang Just Passed 3 Million Downloads

2026-07-18T00:00Z[Etc/UTC]

JBang just passed 3 million binary downloads. 🎉

I honestly never expected that number when I started tinkering with making Java easier to run back in 2019.

But the fun part isn’t the milestone itself. It’s what the numbers behind it reveal. Because somewhere along the way, JBang seems to have grown into something quite different from what I originally set out to build.

First: thank you

Before I dive into numbers, thank you. To everyone who has used JBang, reported a bug, contributed code, created a catalog, built a tool on top of it, mentioned it to a colleague, or just typed jbang into a terminal one day.

A special thank you to Tako Schotanus. JBang would not be what it is today without his contributions.

Open source projects become useful because people find uses for them their creators never anticipated.

Three million downloads is your milestone too.

What does "3 million" actually mean?

The number comes from the GitHub Releases API. It counts downloads of JBang’s actual distributable binary artifacts.

Our download statistics page deliberately separates out version.txt (which JBang uses for update checks) and also excludes checksums and signatures.

This is not a counter inflated by millions of automatic pings.

When we crossed the milestone, the counter showed:

3,000,330 JBang binary downloads

Now, that is not the same as three million unique users. People reinstall. CI systems pull binaries. Machines get replaced. But it does represent real downloads of JBang distributions, not background telemetry.

And people keeps downloading it

JBang started in 2019. Seven years later, it is seeing roughly 1,000 binary downloads every day based on the recent period around the milestone.

That works out to approximately:

30,000 downloads per month
380,000 downloads per year if the recent pace holds

The interesting part isn’t just that JBang eventually reached three million downloads. It is that people keep discovering and installing it, every day, seven years in.

I’d love to tell you exactly when we crossed one million and two million, and draw a nice growth curve. But GitHub only exposes the current cumulative download count per release asset. No historical snapshots.

I’m not going to pretend we have data we don’t have.

We’re starting to record proper snapshots now, so the next milestone can tell that story.

Downloads are only part of the story

JBang also does an async version check, at most once a day per installation, unless it is disabled or finishes too fast for the check to fire.

The anonymous, aggregated data from those checks is published at jbang.dev/usage.

Over the rolling 90-day window: hundreds of thousands of version checks from more than 130 countries.

That is still not a user count. Some installations check in often, some JBang usage is never observed at all. Proxies, short-lived executions, offline environments and disabled checks all create blind spots.

But it paints a picture: there is a large, globally distributed population of JBang installations that keeps showing up.

The geographical spread genuinely inspires me. The United States is the largest single country in the leaderboard, but it’s only around 16% of what we see. The large majority of observed usage is everywhere else.

JBang is very much a global tool.

JBang installations apparently live for a long time

One of the most interesting things in the usage leaderboard is how many old JBang versions still show up in today’s telemetry.

It’s not just people upgrading to last week’s release. Versions from years ago are still checking in.

That tells me JBang has found its way into developer machines, scripts, CI pipelines, internal tooling, workshops, automation… and then just stayed there, doing its job.

That looks less like something people try once.

It looks more like infrastructure.

It spans almost the entire modern Java world

The same data shows JBang running on everything from Java 8 to current releases to early-access builds. And across dozens of JDK vendors: Eclipse Adoptium, Oracle, Ubuntu, Amazon, Homebrew, Azul, Red Hat, GraalVM, Microsoft, and plenty more.

That might be the part I’m most proud of.

JBang was never meant to create or cement another isolated Java ecosystem. The goal was the opposite: work with your Java, on your machine, regardless of where either came from.

The numbers say that’s actually happening.

JBang started as "Java scripting"

The original idea was pretty simple:

Why should running a small Java program require creating an entire project?

I wanted this to feel completely normal:

jbang hello.java

From there came dependency declarations, JDK provisioning, catalogs, app installation, Maven coordinates, aliases, and a lot of other things.

And somewhere along the way, what JBang actually does shifted.

Today a command like:

jbang some-tool@some-catalog

can mean:

Find the tool.
Find the right Java.
Download the required dependencies.
Resolve the application.
Cache what can be cached.
Run it.
Make the same idea work across macOS, Linux and Windows.

The person running the command often does not care about any of that.

They just want to run the app; and JBang made that easy.

Maybe JBang is really a Java distribution layer

I still like the "Java scripting" idea. That’s still an important part of JBang.

But looking at how people actually use it today, I think another description has become just as accurate:

JBang is a zero-friction way to run and distribute Java tools.

A growing number of projects use JBang not because their users want to become JBang users. They use it because their users want to run their tool, and JBang gets the rest out of the way.

No project scaffolding. Possibly no Java installation beforehand. No manual dependency setup. One command, then get on with whatever you actually wanted to do.

I didn’t fully anticipate that role back in 2019. But I think it may now be one of the most important things JBang brings.

Three million, and still counting

So yes:

🎉 JBang has passed three million binary downloads.

That is worth celebrating.

But the more exciting part is what’s behind that number:

thousands of new downloads every week
active installations appearing around the world
usage across almost every corner of the Java ecosystem
old installations that keep quietly doing their jobs
tools using JBang as their own execution and distribution mechanism

A weird little experiment to make Java easier to run has somehow become a piece of Java infrastructure.

That is pretty cool.

Thank you to everyone who helped make it happen. Onwards to the next three million. 🚀

Explore the numbers

The data used in this post is public and continues to change:

Download counts come from GitHub Release asset counters. Usage data is anonymous, aggregated version-check telemetry. Treat it as an interesting signal, not a precise count of users.

From Picocli to Æsh: How Porting JBang's CLI Made Everything Better

2026-06-20T00:00Z[Etc/UTC]

JBang 0.139.2 is out and it ships the biggest internal change in JBang’s history: we replaced picocli with Æsh for all CLI parsing. 5.5× faster native startup, smart tab-completion, a new TUI for dependency search, and (the part I didn’t expect) it made Æsh itself way better in the process.

What started as a framework swap turned into an open-source feedback loop that improved everything it touched. Let me tell you how.

Picocli set the bar

First, credit where it’s due. Picocli by Remko Popma is the best Java CLI framework out there. We’ve used it since JBang’s first commit in 2020 and it served us well: annotation-driven commands, rich help output, nested subcommands, shell completions, you name it. With 5,400+ GitHub stars and a decade of active development, picocli is what made JBang’s CLI experience good in the first place.

So why change?

The speed problem

The short answer: reflection.

Picocli discovers commands and options at runtime using reflection, and that has a cost, especially under GraalVM native image. We measured JBang’s startup at 33ms in native and 228ms on JDK 25 with picocli. That’s fine for most tools. But JBang is something people run as casually as python myscript.py, and at that level the difference between "fine" and "instant" matters.

We’ve had native-image builds of JBang for a while, but could never seriously offer them as the default. 33ms sounds fast until you’re doing tab-completion, where the CLI runs on every keypress. At that speed, you feel the lag.

We needed a framework that could do what picocli does, without the runtime reflection. And that’s where Ståle Pedersen enters the picture.

Enter Ståle and Æsh

Ståle Pedersen is the creator of Æsh (Another Extendable SHell), a Java CLI library that’s been around since 2012, roughly as long as picocli itself. Ståle leads the IBM Runtimes Performance Team from Arendal, Norway, and he knows a thing or two about making Java fast.

Æsh’s trick: it uses a compile-time annotation processor to generate all the command metadata. The generated code is a switch statement that maps options to fields. No reflection at startup, no classpath scanning.

On April 28th, Ståle opened PR #2453: "feat: replace picocli with aesh for CLI parsing." 8,700 lines added, 12,400 removed, across 100 files. A full rewrite of JBang’s CLI layer.

The numbers:

Mode	Picocli	Æsh	Speedup
Native image	33ms	6ms	5.5×
JDK 25	228ms	109ms	2.1×
JDK 11	269ms	149ms	1.8×

Mode

Picocli

Æsh

Speedup

Native image

33ms

6ms

5.5×

JDK 25

228ms

109ms

2.1×

JDK 11

269ms

149ms

1.8×

That’s the difference between "ok, I guess that’s Java" and "wait, is this really Java?"

278 commits in 8 weeks

Porting JBang wasn’t just swapping annotations. JBang uses a lot of picocli features: mutually exclusive options, negatable flags like --[no-]verbose, custom type converters, dynamic completions, help sections, the works.

Ståle didn’t say "sorry, Æsh doesn’t support that." He went and built it. In real time. While the PR was open.

Between April 20th and June 18th, Ståle made 278 commits to Æsh and pushed 16 releases (3.6 through 3.15.1). Nine more releases of aesh-readline. Features he built because JBang needed them:

fallbackValue for three-state option semantics (picocli parity)
DefaultValueProvider with ${env:…} and ${sys:…} resolution
exclusiveWith for mutually exclusive options
HelpSectionProvider for custom help sections
Negatable options rendering as --[no-]name
ANSI-colored help output
Synopsis wrapping at terminal width
Shell completion generators for bash, zsh, fish, and PowerShell
Documentation generators for AsciiDoc and Markdown
GraalVM native-image configuration generation
A BOM module for version management

Every time JBang found something missing, Ståle had it fixed, often the same day. This wasn’t a port anymore, it was a co-evolution.

As Ståle put it on Zulip: "I’m glad we get to 'harden' aesh so quickly :)"

I can’t overstate how impressive this was. Open source is often about finding a project that already does 90% of what you need, and then working around the missing 10%. Ståle didn’t just fill in the gaps, he built the whole bridge while we were crossing it.

The bug too fast to see

My favorite moment from the migration. After merging the Æsh PR, JBang started hanging after certain commands. We tracked it down to a non-daemon thread doing a version check. It had always been there, but picocli was slow enough that it never materialized. Æsh was so fast the main thread finished before the version check could complete, and the JVM hung waiting for the non-daemon thread to exit.

We went from 33ms startup to discovering bugs because 6ms wasn’t giving other threads enough time to start. I’ll take that trade.

"Lets see how many things break"

On June 3rd, we merged the PR. I posted on Zulip: "is now merged, lets see how many things break :)"

Turns out, not much. And ironically that’s thanks to picocli. Over the years we’d built a solid integration test suite around picocli’s behavior. That same test suite is what gave us confidence the Æsh port was correct. The tests didn’t care which framework generated the CLI, they just verified the behavior.

We did have some issues. Tako found that primitive boolean fields behaved differently, especially with jbang config overrides. Ståle had aesh fixes released within a day, even hours. The feedback loop was tight.

The ecosystem gets supercharged

The benefits of this migration didn’t just stay in JBang. Ståle’s work on Æsh made it a much more compelling framework for everyone else.

I know we will see more adoption of Æsh in the Java ecosystem, and that will in turn make it even better. It’s a virtuous cycle of improvement.

We have more things to come building on top of what Æsh enables, and I’m excited to see where it goes.

What you get in 0.139.2

Native binaries (early access)

We now publish GraalVM native-image builds for Linux, macOS, and Windows. Near-instant startup, no JVM required:

export JBANG_USE_NATIVE=true
curl -Ls https://sh.jbang.dev | bash -s - myapp.java

The JVM fallback is always there if native doesn’t work on your platform.

Smart tab-completion

With Æsh fast enough to run on every keypress, we can finally do useful things with completions:

Local files filtered to JBang-supported extensions (.java, .jsh, .kt, .groovy, .md)
Alias names from catalogs (type @ to browse)
Maven GAV completion from your local ~/.m2/repository
GitHub URL navigation, completing files and directories in GitHub repos via API

This works in bash, zsh, and fish today. PowerShell is coming.

TamboUI dependency search

The jbang deps search TUI got a full rewrite from JLine to TamboUI (also by Ståle). Fuzzy match highlighting, async search with debounce, a version picker side pane, and a party trick: paste a Java import statement or compiler error and it auto-searches Maven Central for the right dependency.

Thank you

This migration wouldn’t have happened without a lot of people.

Ståle Pedersen created Æsh, opened the PR, and then made a tons of commits making it ready for real-world use. That kind of responsiveness is what open source makes fun. Tako Schotanus, JBang co-maintainer, found the subtle regressions and Werner Fouche and Juan Antonio Breña Moral helped with additional testing. M. helped Remko Popma built picocli, and our test suite built on picocli is what made this migration safe.

Try it

# Install or update JBang
curl -Ls https://sh.jbang.dev | bash -s - app setup

# Try native mode
export JBANG_USE_NATIVE=true

# Install completions
jbang completion install

# Try the new dependency search TUI
jbang deps search

If something broke or feels different from before, please open an issue. We have a solid test suite but real-world usage always finds things tests don’t.

The full changelog is in the 0.139.2 release notes.

Have fun!

Java in Places You Do Not Expect It

2025-10-17T00:00Z[Etc/UTC]

JBang is about making Java something you can edit, build, run, deploy and share with minimum ceremony and optimally zero friction. This is a work in progress, and this week I feel we got a big step closer to the ultimate goal. Best way to show this? Just try it yourself - it takes 5 seconds.

Try Java in your browser

Click this link → Run Java in your browser - wait a moment and you have a running Java environment, showing Hibernate example in your browser. No JDK or IDE to install, no account, just works.

Or scroll down and click "Activate" below to run Java code right here in this blog post:

      
//DEPS io.jeamlit:jeamlit:0.46.0
//DEPS ch.qos.logback:logback-classic:1.5.19

import org.icepear.echarts.Bar;
import io.jeamlit.core.Nb;
import io.jeamlit.core.Jt;

// only need to run this once - jeamlit shared CSS and web components
display(Nb.getInitHtml(), "text/html");

// some chart
Bar bar = new Bar()
        .setLegend()
        .setTooltip("item")
        .addXAxis(new String[] { "Matcha Latte", "Milk Tea", "Cheese Cocoa", "Walnut Brownie" })
        .addYAxis()
        .addSeries("2015", new Number[] { 43.3, 83.1, 86.4, 72.4 })
        .addSeries("2016", new Number[] { 85.8, 73.4, 65.2, 53.9 })
        .addSeries("2017", new Number[] { 93.7, 55.1, 82.5, 39.1 });

display(Nb.render(Jt.echarts(bar).build()), "text/html");

That is real Java. With real Maven dependencies. Output rendered in your browser with no additional install.

For those curious - above is using Jeamlit to render the chart in your browser. It should look something like this:

Jeamlit is a new library similar to Streamlit for Python, not done by us but inspired by JBang that allows building interactive web apps in Java with zero friction - do check it out!

What was made

I’ve been wanting to use //DEPS in Jupyter Notebooks for a long time, but it has been a pain to set up, so I talked with maintainers of JJava and Rapaio kernels and explored options. Each has their own way of dealing with dependencies - and I prefer to minimize the friction thus I created a JJava derived kernel that supports //DEPS directives in notebooks.

And in doing so I discovered that we could use Python’s existing infrastructure (Jupyter Notebooks, MyBinder and Thebe) to go some steps further.

There is a shockingly small amount of code to make this all work - and its in its infancy still; there is a lot more one can do with this - and I’m hoping you all will help make it better to make Java something you can share and use with zero friction.

Here’s what we’ve built:

Created a custom JBang Jupyter kernel that supports //DEPS directives in notebooks, based on JJava kernel
Built a Binder environment for running Java kernels in your browser with no install
Developed jbang-jupyter-runner extension to run .java/.jsh files directly in Jupyter Lab

Put it all together and you have a way to run Java code in your browser with no additional install.

Note: This is not just for browser-based notebooks - it also works in IntelliJ, VSCode, Cursor and other IDEs that support Jupyter Notebooks.

How to Try It

The fastest way is our new jbang.dev/try page.

In your browser (no install):

Click this Hibernate example
Try custom code
Build your own shareable links for your repositories

Locally (with Jupyter):

jbang install-kernel@jupyter-java --java 25 --enable-preview jbang

Works in IntelliJ, VSCode, Cursor, and any IDE with Jupyter support! If not - let us know!

What This Unlocks

Instant workshops — A browser tab replaces a 45-minute install session.

Runnable documentation — Stop making readers imagine the output. Let them press Run.

Shareable bug reproductions — "Can you reproduce this?" becomes a link, not a setup guide.

API exploration — Test a library with //DEPS, not pom.xml.

This is not about data science or competing with Python.

This is about making Java something you can share with zero friction — all in line with JBang’s mission.

Try It Now

Ready to experience zero-friction Java?

Get started:

Try the interactive demo right now - multiple samples available
Click this Hibernate example to see it in action
Create custom shareable links for your own projects
Install locally: jbang install-kernel@jupyter-java --java 25 --enable-preview jbang

This is still new and evolving - we have more ideas and plans for this, so stay tuned!

This is about making Java something you can share with zero friction — all in line with JBang’s mission.

Enjoy!

Introducing jbang-fmt

2025-09-14T00:00Z[Etc/UTC]

I really did not want to do this, but after I and others tried to convince google-java-format one too many times to not mess with JBang directives like //DEPS or the ///usr/bin/env lines, I finally gave up and made my own.

While I’m a fan of tools like Spotless, their command-line usage is still too cumbersome. This prompted me to create an improved solution called jbang-fmt, in the hope that its key features will be adopted by competing programs and ultimately render itself obsolete

So here it is: https://github.com/jbangdev/jbang-fmt

I would have called it java-fmt as it is not tied to JBang - you can use it as-is with any Java code; but I don’t like visits from lawyers.

Why jbang-fmt?

Simple: One command to format any Java file or directory
Fast: Built for command-line usage and using virtual threads
Flexible: All the options you need (but probably shouldn’t use)
JBang-aware: Respects //DEPS and ///usr/bin/env directives

It is a simple tool that formats Java code using Eclipse Formatter!^[1] but by default does not mess with JBang directives like //DEPS or the ///usr/bin/env lines.

In its simplest form you just do:

jbang-fmt .

And it will format all the Java files recursively in the current directory.

If you want to format specific set of files and directories you can do:

jbang-fmt myscript.java src/main

That’s it - you don’t need to read more, just install it and use it.

Installation

jbang app install jbang-fmt@jbangdev

One more thing…

Since I made this in like 30 minutes as I was being nerd sniped I couldn’t resist adding a few more bell and whistles.

Before I show them - please know - that I really highly recommend you use one format in your project and in many ways I fully agree with google-java-format faq on locking down the formatting rules.

That said - the world is a messy place and we all have different needs - so I like to make formatting easy to do and enable easy experimentation - so I added all the ways I can think of a simple formatting tool could be useful.

`--check`

This is a really simple flag that will check if the code is formatted without making any changes.

jbang-fmt --check .

If the code is not formatted it will exit with a non-zero code. Useful in CI pipelines to fail the build if the code is not formatted and as git pre-commit hooks - see Git Integration for an example of the latter.

Maven and Gradle integration

You can use it from Maven and Gradle using their jbang support - no additional plugins needed. See Maven and Gradle in documentation for more details.

Shortcuts for common "debates"

Tabs vs spaces? Use --indent-with=tab or --indent-with=space
Big vs small monitor? Use --line-length=120 or --line-length=40
Java version nostalgia? Use --java-version=4 for the good old days or --java-version=25 for living on the edge
Compact docs? Use --indent-size=2 etc.

…and if you want full control you can use -Skey=val to override any Eclipse formatter property.

But again, remember I told you to just use one format - above is not meant to be used unless you are ready for war.

In addition it also supports using @-files in case you ignored my advice and want to go crazy on shared formatting.

Conclusion

So - what are you waiting for? Install it and start formatting your code today!

And if you have any feedback, suggestions, or want to contribute, please open an issue on GitHub!

1. I wanted to offer both Google Java Format and Eclipse but Google Java Format even on API level seems to have no consistent ability to ignore lines.

Manifest Tool

2025-08-03T00:00Z[Etc/UTC]

Say hello to mf@jbangdev — the new, delightfully simple way to peek inside any JAR’s manifest!

Ever wondered what secrets lurk in META-INF/MANIFEST.MF? Tired of squinting at cryptic key-value pairs or wrangling with unzip just to see what’s inside? Now you can summon manifest magic with a single command:

mf `jbang info jar com.h2database:h2:2.2.224`

This will use jbang to fetch the jar for h2 and then use mf to print the manifest.

Manifest-Version: 1.0
Implementation-Title: H2 Database Engine
Implementation-URL: https://h2database.com
Implementation-Version: 2.2.224
Build-Jdk: 1.8
Created-By: 1.8.0_281-b09 (Oracle Corporation)
Main-Class: org.h2.tools.Console
Automatic-Module-Name: com.h2database
Bundle-Activator: org.h2.util.DbDriverActivator
Bundle-ManifestVersion: 2
Bundle-Name: H2 Database Engine
Bundle-SymbolicName: com.h2database
Bundle-Vendor: H2 Group
Bundle-Version: 2.2.224
Bundle-License: https://h2database.com/html/license.html
Bundle-Category: jdbc
Multi-Release: true
Import-Package: javax.crypto,javax.crypto.spec,javax.management,javax.naming;resolution:=optional,javax.naming.directory;resolution:=optional,..
Export-Package: org.h2;version="2.2.224",org.h2.api;version="2.2.224",org.h2.constant;version="2.2.224",org.h2.fulltext;version="2.2.224"...
Provide-Capability: osgi.service;objectClass:List=org.osgi.service.jdbc.DataSourceFactory
Premain-Class: org.h2.util.Profiler

Installation

You can run it directly using jbang mf@jbangdev or install it using jbang install mf@jbangdev to get it as a standalone tool.

Structured output

You’ll notice keys like Import-Package and Export-Package are very long and hard to read. mf allows enabling structured output (-s or --structured) that supports certain well-known keys and when enabled will print the values as lists or maps.

mf `jbang info jar com.h2database:h2:2.2.224` -s

Manifest-Version: 1.0
Implementation-Title: H2 Database Engine
...
Import-Package:
  javax.crypto: true
  javax.crypto.spec: true
  javax.management: true
  javax.naming:
    resolution: optional
  javax.naming.directory:
    resolution: optional
  javax.naming.spi:
    resolution: optional
  ...
Export-Package:
  org.h2:
    version: 2.2.224
  org.h2.api:
    version: 2.2.224
  org.h2.constant:
    version: 2.2.224
  org.h2.fulltext:
    version: 2.2.224
...
Provide-Capability: osgi.service;objectClass:List=org.osgi.service.jdbc.DataSourceFactory
Premain-Class: org.h2.util.Profiler

Still long, but much easier to read.

Filtering

mf supports filtering the manifest keys using a regex.

In its simplest form it lets you substring on keys

mf `jbang info jar com.h2database:h2:2.2.224` -s version

Manifest-Version: 1.0
Implementation-Version: 2.2.224
...

but you can also use a regex to filter the keys.

mf `jbang info jar com.h2database:h2:2.2.224` "bundle|version"

Manifest-Version: 1.0
Implementation-Version: 2.2.224
Bundle-Activator: org.h2.util.DbDriverActivator
Bundle-ManifestVersion: 2
Bundle-Name: H2 Database Engine
Bundle-SymbolicName: com.h2database
Bundle-Vendor: H2 Group
Bundle-Version: 2.2.224
Bundle-License: https://h2database.com/html/license.html
Bundle-Category: jdbc

JSON & YAML

Finally, mf supports JSON(--json) and YAML(--yaml) output.

mf `jbang info jar com.h2database:h2:2.2.224` --json

and they can be combined with the other options:

mf `jbang info jar com.h2database:h2:2.2.224` --yaml -s "version|package"

Manifest-Version: "1.0"
Implementation-Version: "2.2.224"
Bundle-ManifestVersion: "2"
Bundle-Version: "2.2.224"
Import-Package:
  javax.crypto: true
  javax.crypto.spec: true
  javax.management: true
  javax.naming:
    resolution: "optional"
  javax.naming.directory:
    resolution: "optional"
  javax.naming.spi:
    resolution: "optional"
  javax.net: true
  javax.net.ssl: true
  javax.script:
    resolution: "optional"
  ...
Export-Package:
  org.h2:
    version: "2.2.224"
  org.h2.api:
    version: "2.2.224"
  org.h2.constant:
    version: "2.2.224"
  org.h2.fulltext:
    version: "2.2.224"
  org.h2.jdbc:
    version: "2.2.224"
  ...

JBang moving into CommonHaus Foundation

2024-04-09T00:00Z[Etc/UTC]

JBang and its associated projects is joining as a founding project of the CommonHaus foundation.

CommonHaus is a brand-new foundation which focus is on providing an independent home for projects like JBang that are funded by independents and with room for project indivduality.

Other founding projects are Hibernate, Jackson, OpenRewrite, JReleaser & Morphia.

Why JBang in a foundation?

The decision to include JBang in a foundation stems from a desire to ensure its long-term sustainability and growth. Being part of a foundation, especially CommonHaus, provides JBang with a stable, independent home that supports its development and promotes collaboration. This move also opens up new opportunities for funding and contributions, further securing the project’s future and fostering an environment where JBang can thrive alongside other like minded open-source projects.

Why CommonHaus?

The guiding principles of CommonHaus summarizes it well:

Honor project and community identity
Offer guidance and support instead of imposing mandates
Maintain transparency in all of our actions
Encourage long-term thinking for sustained project impact

These are important things for JBang - having a place to be hosted for ensuring continuity while still allowing individuality.

What does it mean for users?

JBang will stay JBang. If you as a user notice it has moved, I will be surprised.

Maybe the about text of the CLI will change; that is about it.

What does it mean for contributors?

The exact onboarding implication is still being defined, but it is expected to have minimal impact as we do most of the recommended things anyways.

What’s next?

Try out JBang if you haven’t already. If you see something that could need improvement or have a question, join the development on GitHub, open issues and discussions, and let’s help make Java truly available to anyone.

Have fun!

Introducing jbanghub

2024-04-01T00:00Z[Etc/UTC]

Today we are introducing JBangHub!

JBang always allowed everyone easily make their own java/kotlin/groovy/etc. command line tools available in a jbang catalog. All it takes is that you make a jbang-catalog in your project, organization or website.

This is what makes things like jbang jreleaser@jreleaser and jbang minecraft-server@microsoft possible with minimal effort.

These can then be called as-is or even installed using jbang app install making them available in your PATH directly.

Many already added lots of catalogs and they are visible on the JBang AppStore, readily available to be used from anywhere with JBang available.

This is anywhere you can run java including from javascript and python - yes, even Jupyter Notebooks can access Java with JBang.

To make it even easier and make it possible for anyone to make their favourite tools available under a nice and simple name we are introducing JBangHub, a GitHub organization where we invite everyone to contribute scripts and tools they would like to see easily available.

JBangHub is there to let anyone help any project become more easily accessible to the Java community.

Automatic dependency updates

We made a jbang-catalog template available that setups of a jbang-catalog with automatic renovate bot based updates.

All repos in JBangHub uses this to ensure any Maven referenced artifacts will get updates, but anyone can use this in their own jbang-catalog outside JBangHub too.

Just start it using jbang init -t jbang-catalog and add aliases to your jbang-catalog.

Default Catalog

The latest release (0.116) of JBang adds jbanghub as a default jbang catalog so when you do jbang catalog list you get something like:

This list is not intended to be every jbang-catalog on the planet - but more a teaser on what is available out there. We encourage and accept edits/updates to that list at https://github.com/jbanghub/jbang-catalog.

Help expand

Think something is missing - come contribute your favourite tool at JBangHub.

Have fun!

jbang-python: Java in your Python

2023-09-11T00:00Z[Etc/UTC]

Happy to announce jbang-python - a pypi package which brings your Java to your Python project or notebook.

jbang-python supports running any kind java code that JBang supports.

Wether that is a script from the AppStore, a Maven GAV, a jar or simply a java file stored in your project.

Example

In your requirements.txt add:

jbang-python

or install it using pip install jbang

Then in your python code you can do:

import jbang
output = jbang.exec('--java 21', 'properties@jbangdev', 'java').stdout
print(output)
output = jbang.exec('hello.java').stdout
print(output)

With a hello.java that contains:

//DEPS com.github.lalyos:jfiglet:0.0.8

import com.github.lalyos.jfiglet.FigletFont;

class hello {

    public static void main(String... args) throws Exception {
        System.out.println(FigletFont.convertOneLine(
               "Hello " + ((args.length>0)?args[0]:"jbang")));  ;;
    }
}

When you run this it will automatically install JBang and Java if necessary and then run the requested alias and java code.

Besides using it in your python code locally you can also use it from Jupyter Notebooks.

The jbang-python package is available on pypi and the source code is available on https://github.com/jbangdev/jbang-python.

Have fun!

jbang-npm: Java Script in your JavaScript

2022-04-01T00:00Z[Etc/UTC]

Today we are announcing jbang-npm a npm package which brings you Java Script to your JavaScript project.

jbang-npm joins jbang-maven and jbang-gradle as tools that brings the power of Java Script to your favourite build setup.

jbang-npm supports running any kind java code that JBang supports.

Whether that is a script from the AppStore, a Maven GAV, a jar or simply a java file stored in your project.

Example

Given you have a script name test.js:

#! /usr/bin/env node
const jbang = require('@jbangdev/jbang');
jbang.exec('--java 18', 'properties@jbangdev', 'java');
jbang.exec('hello.java', '"Java Script"')

And in package.json:

{
  "scripts": {
    "test": "node test.js"
  },
  "devDependencies": {
    "@jbangdev/jbang": "^0.1.4"
  }
}

With a hello.java that contains:

//DEPS com.github.lalyos:jfiglet:0.0.8

import com.github.lalyos.jfiglet.FigletFont;

class hello {

    public static void main(String... args) throws Exception {
        System.out.println(FigletFont.convertOneLine(
               "Hello " + ((args.length>0)?args[0]:"jbang")));  ;;
    }
}

When you run this using npm run test it will automatically install JBang and Java if necessary and you get an output like:

In this case JBang was already installed but it did go transparently and downloaded Java 18 as one of the scripts was called with --java 18.

The opportunities are endless!

jbang-npm was contributed by Peter Thomas and Pallafor Yodis from Karate hall of fame.

Very much appreciated and looking forward to see what you make happen with Java Script in your JavaScript!

Have fun!

JBang Rewind 2021!

2022-01-03T00:00Z[Etc/UTC]

We just closed on a very busy 2021 for JBang, and especially in the last few weeks, things progressed quite a bit. Therefore, I thought it would be nice to give a quick overview to recognize the progress and give you a chance to catch up!

December 31st: JDoodle updates their iOS and Android versions to include JBang support. You can now edit and run Java/JBang on the go.
December 29th: Guide to JBang posted on baeldung.com
December 25th: Free IntelliJ License giveaway for one recognized JBang contributor following the steps outlined here. It is a time of writing still open; thus, if you ever opened an issue, contributed an idea or code, or want to contribute, it is still possible to get it!
December 22nd: IntelliJ Plugin made available. Provides direct execution with JBang, content assist for //DEPS and other keywords, and more.
December 1st: JBang was the first entry of 2021 Java Advent Calendar.
November 29th: JDoodle added JBang to its list of supported languages. Making it possible to edit/write Java code using dependencies in a browser without login and additionally embed JBang examples in your blog/guides.
November 24th: Microsoft made a JBang catalog available providing easy launch of Minecraft and Playwright CLI.

And in between, we had four releases of JBang in December with features and bug fixes - heading towards the mythical 1.0 release.

The latest one is 0.86.0 which came on the second anniversary of JBang - or at least the first tweet about it.

Here, one fix was how JBang deals with lib vs. libs that came from a conversation around using JBang in serverless lambda functions. Nándor Holozsnyák just made a blog showing his explorations into this. I was happy to see this as Nandor looked into this because he felt JBang enabled a simple scripting approach comparable to Python/Node - but for Java.

That’s precisely what JBang is about - enabling easy use of Java - I’m expecting to see more enablement of using JBang for more than just scripts in 2022!

Here is to make 2022 about bringing JBang to version 1.0 and making Java fun!

JEP 408: Simple Web Server with JBang

2021-06-03T00:00Z[Etc/UTC]

In March JEP: 408: Simple Web Server was announced. One of JEP 408’s goals is to make an easy to use web server available with Java using java -m jdk.httpserver.

It is a nice idea and I’m looking forward to see it happen.

That said - you do not need to wait for Java 18+ to get this. You can use jbang httpd@jbangdev today with Java 1.8 and upwards.

It is a script I wrote in a few hours after seeing yet another tweet asking for a simple to use webserver. Like JEP 408 it only uses classes available in the JDK, meaning zero additonal download and setup besides installing jbang.

By default, httpd@jbangdev will serve the current directory on https://localhost:8000.

Below is an example of using httpd@jbangdev to serve this website locally from its statically generated Jekyll _site folder on port 8080.

$ jbang httpd@jbangdev -p 8080 -d _site
[jbang] Building jar...
Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) from /Users/max/code/jbangdev/jbang-catalog/_site ...
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/css/main.css" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/js/main.min.js" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/logo.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/carbon-deps.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/carbon-install.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/carbon-java.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/feature-ide.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/feature-version-juggle.svg" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/feature-appstore.png" 200 -
127.0.0.1 - - [04/Jun/2021:00:50:36 +0200] "GET /assets/images/slider/bg-1.jpg" 200 -

As with any other jbang capable application you can also choose to install it in your PATH using jbang app install http@jbangdev. Once you do that you can run it from anywhere using just httpd.

In case you already have application called httpd you can use --name to give it a more unique name:

$ jbang app install --name jhttpd httpd@jbangdev
[jbang] Command installed: jhttpd
$ jhttpd
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) from /Users/max/code/personal/jbangdev/jbang.dev ...

Enjoy - and remember you can find httpd@jbangdev and other apps in JBang AppStore.

JBang Avatar

2020-12-01T00:00Z[Etc/UTC]

It is getting very close to the first anniversary of first commit of JBang.

To celebrate I looked around to see what we could do and was reminded about good old Gource.

With Gource you can render the history of a git repository and get a nice animated video, including flying icons for each author. Trouble is that by default they are just faceless heads - lets get some faces to all those names.

I found a perl script that took all committer emails and located their gravatar image; but it was Perl…so lets make that java instead and use JBang.

The full example is available here, below I’ll walk through the various interesting parts.

If you want to just directly run it do this:

jbang https://github.com/jbangdev/jbang/blob/HEAD/examples/grabavatars.java

To begin with you just get started with jbang init -t cli grab-avatar.

This will create a file named grabavatar.java with some pre-seeded code that does a Hello World! style app using picocli plus it will mark the file as executable.

Setup dependencies and main class

Then in top we are going to add a few dependencies:

Dependencies

The first line is the magic "shebang" line that bash and other shells will interpret but for java it is just a comment. This is what allows you to run the script directly using ./grab-avatar

The dependencies used are as follows:

Picocli for annotation based command line parsing and help generation.
zt-exec is a nice library to execute processes in a nice fluent way.
commons-coded just because default Java don’t have a one-liner for MD5 hash generation.
No Operation slf4j to avoid the default noise slf4j generates.

When you run ./grabavatars.java or jbang grabavatars.java these starting lines with //DEPS in them will be parsed and JBang fetches the dependencies to use during compilation and execution of your script.

The next is the class declaration which is mainly just annotations to define the main picocli command.

class declaration

Iteration over execution

Then the meat of the code is to run git log --pretty=format:%ae|%an" which will return a line for every commit with email and author, like:

max@xam.dk|Max Rydahl Andersen

To do this I use zt-exec which has this great "one-liner" to run the process and for every line output let me process it.

processing command

MD5 and Download

And finally for every identified email and author - generates MD5 and download the url.

processing command

All together now

Now to run this when I have it locally is just: ./grab-avatars in root of a git repository.

But you can also run this directly from a url using:

jbang https://github.com/jbangdev/jbang/blob/HEAD/examples/grab-avatars

And then you can go full out and render with gource - notice the --user-image-dir .git/avatar:

gource --title JBang --stop-at-end --user-image-dir .git/avatar --seconds-per-day 0.05 --auto-skip-seconds 1 -1280x720 --hide filenames -o - | ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i - -vcodec libx264 -preset ultrafast -pix_fmt yuv420p -crf 1 -threads 0 -bf 0 gource.mp4

Then you get a video which with a little bit of magic of video editing that looks something like this:

{#youtube "da0CuVbvWLg" /}

And that is about it - showed how to get started with jbang to port an existing perl script to java using a few dependencies.

See you next time!

Beyond Hello World!

2020-05-28T00:00Z[Etc/UTC]

A simple script you can run with jbang is "Hello World" using jshell (.jsh).

    System.out.println("Hello " + ((args.length>0)?args[0]:"jbang"));

You can run the above by putting it in a file named: hello.jsh and run jbang hello.jsh.

To expand on this we will make a Java file (.java) which uses an external dependency to make the text a bit more fancy.

In this case we’ll use a library called jfiglet.

We use //DEPS com.github.lalyos:jfiglet:0.0.8 to declare this script should run using the dependency with group id: com.github.lalyos, artifact id: jfiglet and with the version 0.0.8.

These are called "artifacts coordinates" or "maven coordinates" as the system originates from the Maven build system; but is today used in almost all Java projects. You can use sites like https://mvnrepository.com to locate the coordinates of projects, and otherwise find them on the website or source repository of the project them self.

Below is a repl.it instance preconfigured with jbang ready to run hello.java using the figlet dependency.

Try and press the Run button to see how it works and then try edit the code to see how it pick up the changes between each run.

JBang

JBang IntelliJ Plugin — Rewritten from Scratch

What changed and why

Per-script classpath isolation

What got fixed

New capabilities

What got removed

Try it

Option 1: Add the EAP update channel (recommended)

Option 2: Install from disk

Somehow, JBang Just Passed 3 Million Downloads

First: thank you

What does "3 million" actually mean?

And people keeps downloading it

Downloads are only part of the story

JBang installations apparently live for a long time

It spans almost the entire modern Java world

JBang started as "Java scripting"

Maybe JBang is really a Java distribution layer

Three million, and still counting

Explore the numbers

From Picocli to Æsh: How Porting JBang's CLI Made Everything Better

Picocli set the bar

The speed problem

Enter Ståle and Æsh

278 commits in 8 weeks

The bug too fast to see

"Lets see how many things break"

The ecosystem gets supercharged

What you get in 0.139.2

Native binaries (early access)

Smart tab-completion

TamboUI dependency search

Thank you

Try it

Java in Places You Do Not Expect It

Try Java in your browser

What was made

How to Try It

What This Unlocks

Try It Now

Introducing jbang-fmt

Why jbang-fmt?

Installation

One more thing…​

--check

Maven and Gradle integration

Shortcuts for common "debates"

Conclusion

Manifest Tool

Installation

Structured output

Filtering

JSON & YAML

JBang moving into CommonHaus Foundation

Why JBang in a foundation?

Why CommonHaus?

What does it mean for users?

What does it mean for contributors?

What’s next?

Introducing jbanghub

Automatic dependency updates

Default Catalog

Help expand

jbang-python: Java in your Python

Example

jbang-npm: Java Script in your JavaScript

Example

JBang Rewind 2021!

JEP 408: Simple Web Server with JBang

JBang Avatar

Setup dependencies and main class

Iteration over execution

MD5 and Download

All together now

Beyond Hello World!

One more thing…

`--check`