Free graphics language software for linux

Open Dice Language project is a language for describing dice rolls.

Open Dice Language is a language for describing dice rolls.

The language is nearly identical to what you see in most role-playing game texts (e.g., "1d20"). It provides several interfaces to the language.

To run in CLI interface mode:

# pushd $ODL_HOME
# java -jar ODL.jar

To run as Widget:

build using `ant widget`
widget is now installed in users widget directory

Tom is a software environment for defining transformations in Java. TOM programming language is an extension of Java designed to manipulate tree structures and XML documents. It is compatible with Java: a Java program is a correct Tom program.
Data are represented using an efficient tree based data-structure. Java built-ins (int, char, String, etc) can be used. Tom provides pattern matching facilities to inspect objects and retrieve values. A powerful strategy language can be used to control transformations.
Enhancements:
- The Eclipse plugin is now available again.
- In the %match construct, the sort of the subject is now optional.
- It is automatically inferred from the patterns when possible.
- Gom generates congruence strategies and offers new functionalities, such as the length of a list.
- A new "!" construct can be used to denote anti-patterns.
- The strategy library has been extended such that strategy expressions can be matched, like any other term.
- A strategy can now take another strategy in its argument.
- Support for Java bytecode analysis and transformation has been added.

PATH is a very different programming language than what you are probably used to if youre an average programmer. If youve programmed in the language Brainf*ck, youll recognize the memory cell architecture. Also, Befunge programmers will recognize the two-dimensional way that PATH programs are laid out.

PATH programs are laid out on a two-dimensional grid. It follows a path of instructions on the program grid, turning 90 degrees when instructed to (hence the name). A character recognized by the interpreter is called an instruction symbol.

To show you what a PATH program actually looks like, heres a simple program that coincidentally spells out the word "PATH" in large ASCII art letters. (You may recognize it from the PATH program homepage, and its also included with the interpreter.) All it does is make the console beep. Ill explain it in detail later, once you know what all the instruction symbols do.

The interpreter starts at the first "$" symbol it finds and starts heading right. Every time it encounters a valid instruction symbol, it executes it. When it encounters certain special symbols, it may turn in another direction.

The interpreter keeps going until it reaches a "#" symbol. If it encounters a character that is not a valid instruction symbol, it ignores it and skips over it.

fid-graphics project is a simple toolkit for the Frigand Imperial Desktop.
It is probably the easiest toolkit to write a display engine for, but it does not support any widgets.
Enhancements:
- src/Desktop/Fid/Window.lhs (displayWaitRedisplay): New function.
- (requestRedisplay): Tidy up.
- src/Desktop/Fid/Main.lhs (data WinCapLine): New type.
- (data WindowType): Use it.
- (&&*, ||*, isnt, haveEnvVar, haveOpt): Deleted.
- (lookupFeature, lookupProtocol, lookupKeywords): New functions.
- (windowTypes): Use WindowCapLine.
- (forkProcess): Unused; deleted.
- (data FidOpt): Unused; deleted.
- (fidMain): Dont consider forking.
- Only call getOpt to sort out verbose options.
- src/Desktop/Fid/Control.lhs (PrimKey): New type.
- (instance Eq PrimKey, instance Ord PrimKey)
- (instance Show PrimKey, instance Arbitrary PrimKey): Instances for t.
- (data Key): Use it.
- (charKey, control, keyToChar): Do the right thing with PrimKey.
- (symbolKey): New function.
- (instance Arbitrary Key): Use instance Arbitrary PrimKey.
- (instance Arbitrary Char): New Instance.

The Complex Language project is an object oriented programming language intended for scripting or rapid prototyping of applications.
The design goals were to have very few simple but powerful concepts and to be easy to use and easy to learn. The project provides a working interpreter along with a complete specification of the language.
Enhancements:
- This is the first release of the specification and the corresponding interpreter.
- The corresponding library is very poor, and there are probably still bugs in the interpreter.

Graphics::Simple is a simple , device-independent graphics API for Perl.

SYNOPSIS

use Graphics::Simple;

line 100,100,200,200;
circle 50,50,25;
stop(); clear(); # Wait for a button press, clear the page

Ever had a Commodore C-64 or Vic-20 or some other of the machines of that era? Where doing graphics was as simple as

line 20,20,50,30;

and you didnt have to go through things like XOpenDisplay etc.

This module tries to bring back the spirit of that era in a modern environment: this module presents a simple, unified API to several different graphics devices - currently X (using Gtk and Gnome) and PostScript.

The interface is primarily made easy-to-use, starting from the idea that the above line command must work. Therefore, it exports most of the primitives by default (you can turn this off).

However, everything is not sacrificed in the name of simplicity: believing in "simple things simple, complicated things possible", this module also allows multiple windows (all the primitives also work as methods of window objects) as well as raw access to the underlying devices - although the device-independence is then lost. In future plans are some sort of interactions with the devices with which it is possible as well as the addition of more devices.

The use command currently accepts the forms

use Graphics::Simple;
use Graphics::Simple qw/line circle/;
use Graphics::Simple 300,400; # portrait paper
use Graphics::Simple 300,400, qw/line circle/;

i.e. the optional size of the default window first and then normal Exporter arguments.

Graphics::Simple has several different back-ends, currently GnomeCanvas, TkCanvas, PostScript and (not fully working yet) Fig. Other backends are expected.
To start Graphics::Simple with a given backend, you should set the environment variable GSIMPL to the value, e.g. by running your script with the command

GSIMPL=PostScript perl gt1.pl

or by setting the environment variable permanently in your shell, by

GSIMPL=PostScript
export GSIMPL

or

setenv GSIMPL PostScript

Gd is a graphics library. It allows your code to quickly draw images complete with lines, arcs, text, multiple colors, cut and paste from other images, and flood fills, and write out the result as a PNG or JPEG file. This is particularly useful in World Wide Web applications, where PNG and JPEG are two of the formats accepted for inline images by most browsers.

In gd 1.0, it stood for "gif draw." After the Unisys patent on the LZW compression used in GIF came to light and GIF support was dropped, it did not officially stand for anything, but lets just say "graphics draw" and leave it at that. (GIF support is back, thanks to the expiration of the patent, but gd can draw much more than GIFs.)

This is a quick install guide:

1. Type ./configure
2. Type make install

Translate! (multi-language) is a Google-based, over-the-network translation desktop widget.

It automatically supports all languages translate.google.com supports as of the moment you start the widget.

(Double-)Click the Wrench button on the middle to chose the language pair.