Free this section consists software for linux

Samoth World Editor project consists of medieval/fantasy universe RPG.
Main features:
- Map loading/creation/saving (the last one almost done, physics still to do)
- Real-time scene viewing
- Scene tree edition
- Node, light, skybox, fog edition
- Physics creation (from mesh) : done, but useless, since they cannot be saved yet.
Enhancements:
- First draw : map editor available, even if not finished.

TransWhite is a simple system status theme.

Also included svg source file with all parts of interface.

Backgrounds for other than 2 filesystems sections also included (to use them You must edit theme file in section karamba, background and mountpoint definitions).

Traffic Control - Next Generation (tcng) is a revision of the Linux network traffic control infrastructure that aims to make the configuration language less cryptic, and provide better interfaces for software and hardware accelerators.
The goal of this project is to revise the network traffic control infrastructure of Linux to overcome shortcomings of the existing architecture, and to make it more extensible.
In particular, we try to resolve the following issues that are present in other similar programs:
Create a more user-friendly configuration language
Provide interfaces for straightforward interaction with network management
Allow seamless integration of hardware accelerators
The code consists of two major components, the traffic control compiler tcng and the traffic control simulator tcsim. Both are described in some more detail below. Since tcng and tcsim share many support files (e.g. the whole regression test system), they are both contained in a single package, called tcng.
This site contains the source code and information directly related to tcng. Pointers to sites with information on traffic control in general can be found in the links section below.
This project started at the beginning of 2001 at EPFL ICA, continued until mid-2002 at Bivio Networks (tm), and has now become one of my spare time activities.
Enhancements:
- the "mtu" parameter in TBF is now optional
- tcsim now uses KVERSION[NUM] instead of KFULLVERSION[NUM] to avoid breaking if EXTRAVERSION contains multiple dots or other surprises (reported by Eduardo Grosclaude)
- scripts/runtests.sh now runs commands with LANG=C, to avoid localized error messages (reported by Eduardo Grosclaude)

Scid project consists of a chess database.

Scid is a powerful chess database application with many search features.

Its GUI makes entering chess games fast and easy, and you can search games by exact position, material, player names, and many other criteria.

It does not come with any actual file of chess games, but it can convert databases to/from the popular PGN format which is widely used for chess games.

ELFIO is a C++ library for reading and generating files in the ELF binary format. This library is unique and not based on any other product. It is also platform independent. The library uses standard ANSI C++ constructions and runs on a wide variety of architectures.
While the librarys implementation does make your work easier: a basic knowledge of the ELF binary format is required. Information about ELF is included in the TIS (Tool Interface Standards) documentation you received with the librarys source code.
The ELFIO library consists of two independent parts: ELF File Reader (IELFI) and ELF Producer (IELFO). Each is represented by its own set of interfaces. The library does not contain any classes that need to be explicitly instantiated. ELFIO itself provides the interfaces that are used to access the librarys functionality.
To make the program recognize all ELFIO interface classes, the ELFIO.h header file is needed. This header file defines all standard definitions from the TIS documentation.
#include < ELFIO.h >
This chapter will explain how to work with the reader component of the ELFIO library. The first step is to get a pointer onto the ELF File Reader:
IELFI* pReader;
ELFIO::GetInstance()->CreateELFI( &pReader );
Now, that there is a pointer on the IELFI interface: initialize the object by loading the ELF file:
char* filename = "file.o";
pReader->Load( filename );
From here, there is access to the ELF header. This makes it possible to request file parameters such as encoding, machine type, entry point, etc. To get the encoding of the file use:
unsigned char encoding = pReader->GetEncoding();
Please note: standard types and constants from the TIS document are defined in the ELFTypes.h header file. This file is included automatically into the project. For example: ELFDATA2LSB and ELFDATA2MSB constants define a value for little and big endian encoding.
ELF binary files consist of several sections. Each section has its own responsibility: some contain executable code; others describe program dependencies; others symbol tables and so on. See the TIS documentation for a full description of each section.
To see how many sections the ELF file contains, including their names and sizes, is demonstated in the following code:
int nSecNo = pReader->GetSectionsNum();
for ( int i = 0; i < nSecNo; ++i ) { // For all sections
const IELFISection* pSec = pReader->GetSection( i );
std::cout GetName() GetSection( .symtab );
Second, create a symbol section reader:
IELFISymbolTable* pSymTbl = 0;
pReader->CreateSectionReader( IELFI::ELFI_SYMBOL,
pSec,
(void**)&pSymTbl );
And finally, use the section reader to process all entries (print operations are omitted):
std::string name;
Elf32_Addr value;
Elf32_Word size;
unsigned char bind;
unsigned char type;
Elf32_Half section;
int nSymNo = pSymTbl->GetSymbolNum();
if ( 0 < nSymNo ) {
for ( int i = 0; i < nSymNo; ++i ) {
pSymTbl->GetSymbol( i, name, value, size,
bind, type, section );
}
}
pSymTbl->Release();
pSec->Release();
All interfaces from the ELFIO library should be freed after use. Each interface has a Release() function. It is not enough to only free the high level interface because one of the sections or readers will still be held and its resources will not be cleared.
The interfaces are freed immediately after their use, in this example we will free only the pReader object:
pReader->Release();
The source code for the ELF Dumping Utility can be found in the "Examples" directory; included there are more examples on how to use different ELFIO reader interfaces.
Enhancements:
- Fixes endian conversion in the ELFIRelocation and ELFINote sections adapters.

JRicochet is a simple puzzle game. It consists of a 10x10 grid, which contains 5 invisible blocks. From each side a player can shoot probes into the grid. Goal is to find the blocks by the pattern of the ricochetting probes in as few shots as possible.

DataparkSearch Engine is a web-based search engine released under the GNU General Public License, full-featured and designed to organize search within a web-site, group of web-sites, intranet or local system.
DataparkSearch consists of two parts. The first part is indexing mechanism (indexer). Indexer walks over html hypertext references and stores found words and new references into database. The second part is web CGI front-end to provide search using data collected by indexer.
Main features:
- Support for http, https, ftp, nntp and news URL schemes.
- htdb virtual URL scheme support for indexing SQL databases.
- text/html, text/xml, text/plain, audio/mpeg (MP3) and image/gif mime types built-in support.
- External parsers support for other document types.
- Ability to index multilingual sites using content negotiation.
- Searching all of the word forms using ispell affixes and dictionaries.
- Fuzzy searching based on acronyms and abbreviations.
- Stop-words, synonyms and acronyms lists.
- Boolean query language support.
- Neural network based Popularity Rank.
- Results sorting by relevancy, popularity rank, last modified time and by importance (a multiplication of relevancy and popularity rank).
- Various character sets support.
- Accent insensitive search.
- Phrases segmenting for Chinese, Japanese, Korean and Thai languages.
- mod_dpsearch - search module for Apache web server.
- Internationalized Domain Names support.
Enhancements:
- Tags and categories are now stored in the urlinfo table and can be set on a per-document basis.
- Support for crosswords has been implemented for cache dbmode.
- Automatic phrase search has been implemented for compound words.
- The full method of relevance calculation has been modified.
- Conditional operators can now be used in the variables section of the template.
- Storing documents in stored database has been fixed for non-default values of StoredFiles.
- The -f switch has been added for cached, search, and stored: use to run them in the foreground (dont daemonize).
- Several bugs were fixed.