Free intermediate software for linux

Lightfeather is a 3D engine for Linux, Mac OS X and Windows. Lightfeather project is designed to be easy to use but still take advantage of the features of modern graphics hardware.
The zlib/libpng license under which it is distributed allows you to use it for any purpose whatsoever including commercial projects without the need to redistribute your changes in any form or even mentioning that you use it (although that would be nice, of course).
To use Lightfeather you need to be proficient in c++ programming (a python binding is in the works at the moment so you might be able to use Lightfeather with python in the future). It is geared towards intermediate to professional programmers and not towards beginners.
Before you start working with Lightfeather you should AT LEAST read the Modelconverter and the Renderpasses information in the documentation submenu.
If you want to help with Lightfeathers development, there are lots of possibilities to do so. You could, for example, submit patches, contribute models for the test and example applications or write tutorials. If you want to work on the engine but dont know where to start look into the todo/request list. Help in any form is always very welcome.
Enhancements:
- It is now possible to render the same scene through different cameras into multiple windows.
- A filesystem handler interface has been added, which allows the use of a database or an FTP server like a normal filesystem.
- Resources can be grouped for easier handling.
- Users can integrate their own data into the engines lfm file format.
- Many more changes were made and lots of bugs were fixed.

eCromedos is a document preparation system that allows concurrent publication of documents in print and web.
Documents are written in an XML-conforming markup language and converted to HTML or printable document formats by means of a special software.
eCromedoss defines document formats for a range of document classes, which are formally layed down in a set of Document Type Definitions (DTD). The mapping of raw documents to representational formats is done via XSL-transformations.
The eCromedos Document Processor (EDP) is a modified XSL-transformer with a plugins-based architecture, through which it offers enhanced functionality which could not be realised with XSL-transformations alone. The most salient feature is the possibility to have listings in various programming languages syntactically highlighted during transformation.
For production of printable documents, the EDP generates LATEX as an intermediate format, which can be further processed into high-quality PostScript and PDF by use of the TEX typesetting system. All that is needed is a functional TEX-installation. The user does not need any previous knowledge about TEX or LATEX.
Enhancements:
- This release contains a number of major bugfixes and a couple of minor corrections and additions to the documentation.
- Users of version 1.0.0 are encouraged to upgrade.

The libdisasm library provides basic disassembly of Intel x86 instructions from a binary stream. The intent is to provide an easy to use disassembler which can be called from any application; the disassembly can be produced in AT&T syntax and Intel syntax, as well as in an intermediate format which includes detailed instruction and operand type information.

This disassembler is derived from libi386.so in the bastard project; as such it is x86 specific and will not be expanded to include other CPU architectures. Releases for libdisasm are generated automatically alongside releases of the bastard; it is not a standalone project, though it is a standalone library.

The recent spate of objdump output analyzers has proven that many of the people [not necessarily programmers] interested in writing disassemblers have little knowledge of, or interest in, C programming; as a result, these "disassemblers" have been written in Perl.

Usage

The basic usage of the library is:

1. initialize the library, using disassemble_init()
2. disassemble stuff, using disassemble_address()
3. un-initialize the library, using disassemble_cleanup

These routines have the following prototypes:

int disassemble_init(int options, int format);
int disassemble_cleanup(void);
int disassemble_address(char *buf, int buf_len, struct instr *i);

Instructions are disassembled to an intermediate format:

struct instr {
char mnemonic[16];
char dest[32];
char src[32];
char aux[32];
int mnemType; /* type of instruction */
int destType; /* type of dest operand */
int srcType; /* type of source operand */
int auxType; /* type of 3rd operand */
int size; /* size of insn in bytes */
};

The sprint_address() can be used in place of the disassemble_address() routine in order to generate a string representation instead of an intermediate one:

int sprint_address(char *str, int len, char *buf, int buf_len);

...so that a simple disassembler can be implemented in C with the following code:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
char line[LINE_SIZE]; /* buffer of line to print */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
/* disassemble address to buffer */
size = sprint_address(buf + pos, BUF_SIZE - pos, line, LINE_SIZE);
if (size) {
/* print instruction */
printf("%08X: %sn", pos, line);
pos += size;
} else {
printf("%08X: Invalid instructionn");
pos++;
}
}

disassemble_cleanup();

Alternatively, one can print the address manually using the intermediate format:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */
struct instr i; /* representation of the code instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
disassemble_address(buf + pos, BUF_SIZE - pos, &i);
if (size) {
/* print address and mnemonic */
printf("%08X: %s", pos, i.mnemonic);
/* print operands */
if ( i.destType ) {
printf("t%s", i.dest);
if ( i.srcType ) {
printf(", %s", i.src);
if ( i.auxType ) {
printf(", %s", i.aux);
}
}
}
printf("n");
pos += size;
} else {
/* invalid/unrecognized instruction */
pos++;
}
}

disassemble_cleanup();

This is the recommended usage of libdisasm: the instruction type and operand type fields allow analyzing of the disassembled instruction, and can provide cues for xref generation, syntax hi-lighting, and control flow tracking.

PHP Running Management or phpRunMan is a set of scripts for runners. Users can enter intermediate times of their training or race performance for calculating various statistics (distance, avg speed, time/km, projection on different distance, etc.). In PHP Running Management you can enter comments for the whole run or every intermediate segment so the data can be used as a logbook.

Every run (training or competition) is entered as a list of segments and times. You can specify the number of laps and the "offset" (manual correction) of the distance.

Several views are proposed:

- Year view: displays all the runs with their distance, time, average speed, etc.
- Detail view: shows the profile of a run by segment (time, speed, cumulated distance and other indicators).
- Month view: aggregates runs per month over the selected year, shows every months distance, time, average speed.

All the scripts are written in PHP (requires GD lib activated too) and the data is stored in MySQL database.

This study guide from Linux Holdings will help you to train for the Linux LPI 101 exam.

Linux Holdings is a linux and Open Source training company, training Linux Administration as the core focus.

These are not the only Open Source courses we offer, but the most popular.

Training info

Linux Holdings offer a full spectrum of Linux and open source courses. These start from basic low-level courses to the very advanced administration courses.

All our administration courses are based on the international LPI certification. Our trainers are the best available in South Africa. They are not just excellent Linux administrators with many years experience; they are also the best trainers in the industry. Good administrators are not necessarily good trainers; we give you the best of both sides.

Our entry-level and intermediate courses include the ICDL for OpenOffice.org. We have a full marketing and development department constantly developing and updating courses. Linux Holdings invests huge amounts of time and resources in development, testing and research to give the best training available today.

Our quality department ensures that all students are trained to the highest standard possible. It is also the quality departments duty to ensure that students start with the right course so the learning gradient is not to high or to low. Speak to us so that we can suggest the proper courses for your IT experience.

RAVE 1.9.9 is yet another excellent utility for everyone. RAVE stands for Retrospective Analysis and Visualization Engine which is a framework for generating complex analysis products.

RAVE caches the intermediate results of analytic tasks for later use in the same or different analyses. This improves performance by reducing duplicated effort when generating analytic results. RAVE users need to do nothing special in order to take advantage of this performance improvement.

The RAVE project provides tools to use RAVE interactively in a terminal, or to publish "live" RAVE analyses online as a network service for use in network-enabled applications.

Requirements:

• Python 2.4 or higher

MyBook World Edition Packages project collection provides pre-compiled packages for hacking Western Digital MyBook World Edition, to improve performance and add new features.

At least intermediate Linux experience is required for playing with MyBook. Please, if you do not meet this requirement, ask someone experienced to help you. Otherwise there is a risk that you will brick your MyBook!