Free jars of clay software for linux

Jar Ajar is a JAR-based self-extractor for zip files. Jar Ajar project can package zipped files with descriptive images and text using a graphical interface.
When recipients launch the resulting JAR, Jar Ajar guides users through the unzip process.
Jar Ajar is designed specifically for software deployment of Java-based applications. By taking advantage of the Java environment that would already be found on the users platform, Jar Ajar is very lightweight and offers a consistent look and feel.
Packaging. Features to help you package files for deployment:
- Welcome message: supports HTML and CSS-compliant text.
- Logo & License: allows you to include a customized logo and license.
- Zip: Jar Ajar zips up your files into a self-extracting .jar file.
- Documented: instructions are built right into the sidebar for quick access.
Self-Extraction. The self-extractor means that you can install your package on any computer that support Java. The general sequence of events during an installation include:
- Greetings from your welcome message.
- Required acceptance of your license.
- Browse for installation location.
- Install the files, with feedback on which files have been installed.
- Wrap-up, including a reminder of where the files have been installed to, and the option to open a readme and launch your program.
Enhancements:
- New features in this release include the ability to display a license during self-extraction and a readme afterward.
- Jar Ajar can now also launch programs after extraction.
- Hyperlinkable text displays are now supported.
- User interface improvements were made.

JSmancala project is a Javascript/DHTML implementation of the strategy board game "Mancala". Runs in the browser with several challenging computer intelligence levels. Play human versus computer, human versus human or computer versus computer.

JSmancala is a Javascript/DHTML implementation of the board game "Mancala". Traditionally, Mancala is played with small stones on a wooden board with little cups scooped out.

Mancala is very easy to play. It is a two player game. The object is to collect as many of the stones as possible.

Each player controls one side of the board. On a traditional (real) board, the player controls the side closest to him. Each side of the board has six "cups" and one "jar". The "cups" are spaces along the length of the board and the "jar" is a larger space at the end of the board. When the game begins, each "cup" contains 4 stones and each "jar" is empty.
Play begins when one player selects a "cup" on his side of the board and removes all of the stones from it. The stones are then redistributed in the other "cups" on the players side, one stone at a time, moving toward the right. If any stones remain after the last "cup" has had a stone added to it, one stone is placed in the players "jar" and the redistribution continues on the opponents side of the board. Redistribution continues in a counterclockwise manner until all the stones have been placed. No stones are ever placed in the opponents jar when the player is making his move.

Once a stone is placed in a players "jar", it cannot be removed.
There are two twists. First, if the last stone being redistributed lands in the players "jar", the player gains an extra turn.

Second, if the last stone being redistributed lands in an empty "cup" on the players side of the board and the "cup" on the opposite side of the board is not empty, the stones in both "cups" are "captured". Captured stones are immediately removed from both "cups" and placed in the players "jar".

Play ends when there are no stones in any "cup" on one of the sides of the board, regardless of whose turn it is.

A players score is determined by totalling all of the stones in his "cups" and his "jar". The player with the highest score wins.

This version allows the user to play the computer, another human or watch the computer play itself. The computer players have five levels of "intelligence", rated from "foolish" to "wise". An "advice" button is also provided that the player may click at any time during his turn. It will use the "computer intelligence level" set for the player to calculate the best move. That move will be highlighted on the board.

One-JAR is a simple solution to the problem of distributing an application as a single jar file, when it depends on multiple other jar files.

It uses a custom classloader to discover library jar files inside the main jar.

Java EDF files viewer is a multiplatform (Linux and Windows) EDF (European Data Format) files viewer written in Java and developped with Borland JbuilderX Foundation.
Usage
1. You need the Java software installed.
2. To execute the viewer
- type in command line: java -jar jEDF.jar
Enhancements:
- This release has hypnogram scoring, montage creation, spectral analysis, EEG event scoring, and a bilingual interface (English/French).

Camera_AXIS is a Java application for viewing images generated by an AXIS 2100 network camera. The camera generates a video stream in MJPG format.

The java source code can be browsed online or downloaded in tgz format. The application uses the Base64 encoder from Robert Harder (distributed with Camera_AXIS). Installation is simple:

make

Start the application using te command:

make test

Configuration parameters are saved in .java.cfg. This file is created the first time you start the application and contains the URL of the camera and the user id and password of the camera administrator. Without the id and/or the password, you can still view images from the camera, but you wont be able to change its settings. Proxy settings are taken from the http_proxy environment variable (if present).

A precompiled jar-file is also available. Execute it with java -jar AXIS.jar.

ProGuard is a free Java class file shrinker, optimizer, and obfuscator. ProGuard project can detect and remove unused classes, fields, methods, and attributes. It can then optimize bytecode and remove unused instructions.
Finally, it can rename the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
More compact jar files also means smaller storage requirements, faster transfer of applications across networks, faster loading, and smaller memory footprints.
ProGuards main advantage compared to other Java obfuscators is probably its compact template-based configuration. A few intuitive command line options or a simple configuration file are usually sufficient. For instance, the following configuration option preserves all applets in a jar:
-keep public class * extends java.applet.Applet
The user manual explains all available options and shows more examples of this powerful configuration style.
ProGuard is fast. It only takes seconds to process programs and libraries of several megabytes. The results section presents actual figures for a number of applications.
ProGuard is a command-line tool with an optional graphical user interface. It also comes with plugins for Ant and for the J2ME Wireless Toolkit.
ProGuard is a Java class file shrinker, optimizer, and obfuscator. The shrinking step detects and removes unused classes, fields, methods, and attributes. The optimization step analyzes and optimizes the bytecode of the methods. The obfuscation step renames the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
ProGuard can also be used to list unused fields and methods in an application, and to print out the internal structure of class files.
ProGuard typically reads the input jars (or wars, ears, zips, or directories). It then shrinks, optimizes, and obfuscates them. It then writes the results to one or more output jars (or wars, ears, zips, or directories). The input jars can optionally contain resource files. ProGuard copies all non-class resource files from the input jars to the output jars. Their names and contents remain unchanged.
ProGuard requires the library jars (or wars, ears, zips, or directories) of the input jars to be specified. It can then reconstruct class hierarchies and other class dependencies, which are necessary for proper shrinking, optimization, and obfuscation. The library jars themselves always remain unchanged. You should still put them in the class path of your final application.
In order to determine which code has to be preserved and which code can be discarded or obfuscated, you have to specify one or more entry points to your code. These entry points are typically classes with main methods, applets, midlets, etc.
- In the shrinking step, ProGuard starts from these seeds and recursively determines which classes and class members are used. All other classes and class members are discarded.
- In the optimization step, ProGuard further optimizes the code. Among other optimizations, classes and methods that are not entry points can be made final, and some methods may be inlined.
- In the obfuscation step, ProGuard renames classes and class members that are not entry points. In this entire process, keeping the entry points ensures that they can still be accessed by their original names.
Any classes or class members of your code that are created or invoked dynamically (that is, by name) have to be specified as entry points too. It is generally impossible to determine these cases automatically, but ProGuard will offer some suggestions if keeping some classes or class members appears necessary. For proper results, you should at least be somewhat familiar with the code that you are processing.
ProGuard does handle Class.forName("SomeClass") and SomeClass.class constructs automatically. The referenced classes are preserved in the shrinking phase, and the string arguments are properly replaced in the obfuscation phase. With variable string arguments, it is generally impossible to determine their possible values (they might be read from a configuration file, for instance).
However, as mentioned, ProGuard will note constructs like "(SomeClass)Class.forName(variable).newInstance()". These might be an indication that the class or interface SomeClass and/or its implementations may need to be preserved. You can then adapt your configuration accordingly.
Whats New in 3.9 Stable Release:
- This release fixes a number of bugs.
- Notably, ".class" constructs compiled in Java 6 are now handled correctly.
- The optimization step now avoids a possible division by 0 and correctly processes local variables with indices larger than 255.
- The documentation and examples have been updated.
Whats New in 4.0 Beta Development Release:
- Added preverifier for Java 6 and Java Micro Edition, with new option -dontpreverify.
- Added new option -target to modify java version of processed class files.
- Made -keep options more orthogonal and flexible, with option modifiers allowshrinking, allowoptimization, and allowobfuscation.
- Added support for configuration by means of annotations.
- Improved shrinking of unused annotations.
- Added check on modification times of input and output, to avoid unnecessary processing, with new option -forceprocessing.
- Added new options -flattenpackagehierarchy and -repackageclasses (replacing -defaultpackage) to control obfuscation of packages names.
- Added new options -adaptresourcefilenames and -adaptresourcefilecontents, with file filters, to update resource files corresponding to obfuscated class names.
- Now respecting naming rule for nested class names (EnclosingClass$InnerClass) in obfuscation step, if InnerClasses attributes or EnclosingMethod attributes are being kept.
- Added new inter-procedural optimizations: method inlining and propagation of constant fields, constant arguments, and constant return values.
- Added optimized local variable allocation.
- Added over 250 new peephole optimizations.
- Improved making classes and class members public or protected.
- Now printing notes on suspiciously unkept classes in parameters of specified methods.
- Now printing notes for class names that dont seem to be fully qualified.
- Added support for uppercase filename extensions.
- Rewritten class file I/O code.
- Updated documentation and examples.

JTail is an advanced Java/Swing implementation of the Unix tail utility. JTail includes an intuitive GUI interface that enables the user to define multiple data filters and alarms.
In addition, the user can suspend and resume the display of data from the monitored file. When suspended, the user can single step through the new data being written to the files being monitored.
JTail can be used to monitor both files on both local systems and via the Fishcroft RfaServer (see below) on remote systems.
Enhancements:
- The JTail jar file is now a self-executing jar file.
- The ability to spawn new root windows from the File menu has been added.
- When filters are defined but none are activated, all output will be displayed.
- Output may be displayed with line wrap toggled on or off.
- Minor code cleanup. rfa.jar sources are included in the source tree.
- utils.jar sources are included in the source tree.

ScannerDaemon is the virus scanner of the OpenAntivirus project. You can send a filename to it via simple TCP and it will scan the file for viruses and tell you if the file is infected or not.
The ScannerDaemon listens on localhosts port 8127 for absolute filenames and absolute directorynames. It scans the files/all files in the directory and reports OK if no virus has been found or FOUND: if a virus has been detected.
You can start the ScannerDaemon simply by typing:
java -jar ScannerDaemon.jar
If you did not forget the Credo-files, it should come up and listen on port 8127. You can also give the name of the directory as a command-line parameter, like
java -jar ScannerDaemon.jar -credo.directory
Enhancements:
- Adaptions to new listener and filter scheme
- Bugfix: allow more than one signature file in one credo file
- Bugfix: close files used by UPXFilter
- Bugfix: wrong failure transitions
- Improvement: less memory consumption for nodes
- Improvement: UPXFilter scans uncompressed and compressed file