Thank you for your interest in Bean Sheet -- an interpretive Java spreadsheet utilizing Java spec syntax. At its core is Bean Shell, an open source Java interpreter. Because Bean Shell has full access to the Java Virtual Machine, the potential of marrying a Java interpreter with the concepts of a spreadsheet application is beyond and different from traditional spreadsheet software. Each Bean Sheet document can be a powerful application in its own right.

Please refer to the main Bean Sheet site for downloadsdocumentation and more.  Javadoc API documentation for the latest release can be found here. Don't forget to join the users' mailing list. I'd love to hear from you!

Installing Bean Sheet

Currently, Bean Sheet comes packaged in the following options:

Turn-key Binary (bsheet-<version>.zip)

This package is the simplest to install. You will simply need to download the self-executing JAR file and... well, execute it. The Bean Shell library included in this package contains all Bean Shell commands.

java -jar bsheet_bundle.jar

Building from source code with Ant (bsheet_src-<version>.zip)

You will need a working copy of Ant. You will also need to install a Bean Shell library JAR in <Bean Sheet home>/code/lib directory. Extract the contents of into <Bean Sheet home>/code. The following Ant targets are of interest:


Generates a bundled self-executing JAR that includes Bean Sheet and Bean Shell libraries.


Deletes compiled classes and Javadoc directories.


Generates a source zip.


Compiles the source.


Compiles the source and generates a self-executing JAR without Bean Shell library.


Generates Javadoc documentation.


Calls code_zip, jar, and bundle targets.


Compiles the source and launches the application.

Executing “jar” and “bundle” targets (ant jar bundle) will result in bsheet_bundle.jar being generated. Bean Sheet can now be executed without any extension modules.

There are a number of modules that come with Bean Sheet as part of the bsheet download. Those modules, while not technically required for the application to run, are considered an integral part of it, as an end user package. The following modules will need to be downloaded and built: mod_commands, mod_help, mod_print, mod_toolbar. With the exception of mod_commands, each module will need to be compiled and configured. Extract into <Bean Sheet home>/module directory. You've now set up mod_commands – it is the only module that does not require compilation. Now we'll move on to the other modules. It is recommended, for simplicity and ease of use, to first download and extract a pre-compiled Bean Sheet distribution in order to make sure some of the files that do not come with module source code are in place.

Each of the mod_help, mod_print, and mod_toolbar source zip files will need to be extracted into the separate module directories under <Bean Sheet home>/module/help, <Bean Sheet home>/module/print, <Bean Sheet home>/module/toolbar. Extract each module's source zip file into a corresponding module directory. Help module requires an external library jar (helpgui-1.1.jar, HelpGUI official site), which can also be obtained from a binary bsheet distribution. In each one, execute ant release command. You will also need to have a configuration properties file for each of these modules (,, placed in <Bean Sheet>/home/module directory. It is easiest to obtain these properties files from a pre-compiled distribution of bsheet package. Your final contents of <Bean Sheet home>/module should contain at least the following:

You should now be able to run Bean Sheet with each of the included modules.

Screen Capture Video

With the help of Screencast-O-Matic, we're happy to offer a demo screen capture video. You will need Java 1.5 or later to play it.

Sample Documents

Right-click on the screen shots and save to download the documents.

Category Tree Editor

Fun with Google Translations

Contractor's Time Sheet

Bean Sheet and Functional Programming

The first thing most of you will say is probably, "What the heck is functional programming?"  Until very recently, that would have been my reaction as well.  As luck would have it though, I came across something that made me understand what it is exactly that I like about spreadsheets in general.  Consider for a moment how we work with typical spreadsheets: we fill some cells with data, and some with formulas or functions.  Those formulas and functions usually refer to other cells, which may contain data or functions themselves.  We never have to think about dependencies or the order in which cells are evaluated.  This in itself is a simple form of functional programming.  The idea is that the user of a functional programming environment concentrates on the task at hand from a more mathematical point of view, defining functions and data inter-relationships rather than writing instructions for specific variable manipulation to be executed in some specific order.  There are several functional programming languages and a whole community devoted to them.

As you can see, a generic spreadsheet application has some elements of a functional programming environment built into it and it is for that reason a lot of people find them to be excellent modeling tools and fairly easy to "program" in.  Bean Sheet, being a spreadsheet and a Java scripting environment presents its user with the potential to make the best of both paradigms.  For example, consider Bean Sheet command condition.  This command takes two parameters: an cell range (Iterator of Point objects) and an expression that is evaluated for each cell in the cell range.  This command returns a cell range that is a subset of the passed in cell range, such that the expression given evaluates to true for each cell.  The expression can of course do more than simply return a boolean result.  A function defined in this kind of all-elements-such-that style is a perfect example of functional programming.  But of course Bean Sheet is not a pure functional programming environment.  It does not force its users to completely shift their thinking into the functional programming frame of mind.  Rather it's a very interesting and powerful, though admittedly accidental, side-effect of combining OO concepts, an interpreter, and a spreadsheet.  Welcome to functional Java!